improved code formatter
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpeclipse / internal / compiler / ast / EqualExpression.java
1 /*******************************************************************************
2  * Copyright (c) 2000, 2003 IBM Corporation and others.
3  * All rights reserved. This program and the accompanying materials 
4  * are made available under the terms of the Common Public License v1.0
5  * which accompanies this distribution, and is available at
6  * http://www.eclipse.org/legal/cpl-v10.html
7  * 
8  * Contributors:
9  *     IBM Corporation - initial API and implementation
10  *******************************************************************************/
11 package net.sourceforge.phpeclipse.internal.compiler.ast;
12
13 import net.sourceforge.phpdt.internal.compiler.IAbstractSyntaxTreeVisitor;
14 import net.sourceforge.phpdt.internal.compiler.codegen.Label;
15 import net.sourceforge.phpdt.internal.compiler.flow.FlowContext;
16 import net.sourceforge.phpdt.internal.compiler.flow.FlowInfo;
17 import net.sourceforge.phpdt.internal.compiler.impl.Constant;
18 import net.sourceforge.phpdt.internal.compiler.lookup.ArrayBinding;
19 import net.sourceforge.phpdt.internal.compiler.lookup.BlockScope;
20 import net.sourceforge.phpdt.internal.compiler.lookup.MethodBinding;
21 import net.sourceforge.phpdt.internal.compiler.lookup.ReferenceBinding;
22 import net.sourceforge.phpdt.internal.compiler.lookup.Scope;
23 import net.sourceforge.phpdt.internal.compiler.lookup.TypeBinding;
24
25 public class EqualExpression extends BinaryExpression {
26
27 public EqualExpression(Expression left, Expression right,int operator) {
28         super(left,right,operator);
29 }
30 public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {
31         if (((bits & OperatorMASK) >> OperatorSHIFT) == EQUAL_EQUAL) {
32                 if ((left.constant != NotAConstant) && (left.constant.typeID() == T_boolean)) {
33                         if (left.constant.booleanValue()) { //  true == anything
34                                 //  this is equivalent to the right argument inits 
35                                 return right.analyseCode(currentScope, flowContext, flowInfo);
36                         } else { // false == anything
37                                 //  this is equivalent to the right argument inits negated
38                                 return right.analyseCode(currentScope, flowContext, flowInfo).asNegatedCondition();
39                         }
40                 }
41                 if ((right.constant != NotAConstant) && (right.constant.typeID() == T_boolean)) {
42                         if (right.constant.booleanValue()) { //  anything == true
43                                 //  this is equivalent to the right argument inits 
44                                 return left.analyseCode(currentScope, flowContext, flowInfo);
45                         } else { // anything == false
46                                 //  this is equivalent to the right argument inits negated
47                                 return left.analyseCode(currentScope, flowContext, flowInfo).asNegatedCondition();
48                         }
49                 }
50                 return right.analyseCode(
51                         currentScope, flowContext, 
52                         left.analyseCode(currentScope, flowContext, flowInfo).unconditionalInits()).unconditionalInits();
53         } else { //NOT_EQUAL :
54                 if ((left.constant != NotAConstant) && (left.constant.typeID() == T_boolean)) {
55                         if (!left.constant.booleanValue()) { //  false != anything
56                                 //  this is equivalent to the right argument inits 
57                                 return right.analyseCode(currentScope, flowContext, flowInfo);
58                         } else { // true != anything
59                                 //  this is equivalent to the right argument inits negated
60                                 return right.analyseCode(currentScope, flowContext, flowInfo).asNegatedCondition();
61                         }
62                 }
63                 if ((right.constant != NotAConstant) && (right.constant.typeID() == T_boolean)) {
64                         if (!right.constant.booleanValue()) { //  anything != false
65                                 //  this is equivalent to the right argument inits 
66                                 return left.analyseCode(currentScope, flowContext, flowInfo);
67                         } else { // anything != true
68                                 //  this is equivalent to the right argument inits negated
69                                 return left.analyseCode(currentScope, flowContext, flowInfo).asNegatedCondition();
70                         }
71                 }
72                 return right.analyseCode(
73                         currentScope, flowContext, 
74                         left.analyseCode(currentScope, flowContext, flowInfo).unconditionalInits()).asNegatedCondition().unconditionalInits();
75         }
76 }
77 public final boolean areTypesCastCompatible(BlockScope scope, TypeBinding castType, TypeBinding expressionType) {
78         //see specifications 5.5
79         //A more complete version of this method is provided on
80         //CastExpression (it deals with constant and need runtime checkcast)
81
82         if (castType == expressionType) return true;
83
84         //========ARRAY===============
85         if (expressionType.isArrayType()) {
86                 if (castType.isArrayType()) { //------- (castTb.isArray) expressionTb.isArray -----------
87                         TypeBinding expressionEltType = ((ArrayBinding) expressionType).elementsType(scope);
88                         if (expressionEltType.isBaseType())
89                                 // <---stop the recursion------- 
90                                 return ((ArrayBinding) castType).elementsType(scope) == expressionEltType;
91                         //recursivly on the elts...
92                         return areTypesCastCompatible(scope, ((ArrayBinding) castType).elementsType(scope), expressionEltType);
93                 }
94                 if (castType.isBaseType()) {
95                         return false;
96                 }
97                 if (castType.isClass()) { //------(castTb.isClass) expressionTb.isArray --------------- 
98                         if (scope.isJavaLangObject(castType))
99                                 return true;
100                         return false;
101                 }
102                 if (castType.isInterface()) { //------- (castTb.isInterface) expressionTb.isArray -----------
103                         if (scope.isJavaLangCloneable(castType) || scope.isJavaIoSerializable(castType)) {
104                                 return true;
105                         }
106                         return false;
107                 }
108
109                 return false;
110         }
111
112         //------------(castType) null--------------
113         if (expressionType == NullBinding) {
114                 return !castType.isBaseType();
115         }
116
117         //========BASETYPE==============
118         if (expressionType.isBaseType()) {
119                 return false;
120         }
121
122
123         //========REFERENCE TYPE===================
124
125         if (expressionType.isClass()) {
126                 if (castType.isArrayType()) { // ---- (castTb.isArray) expressionTb.isClass -------
127                         if (scope.isJavaLangObject(expressionType))
128                                 return true;
129                 }
130                 if (castType.isBaseType()) {
131                         return false;
132                 }
133                 if (castType.isClass()) { // ----- (castTb.isClass) expressionTb.isClass ------ 
134                         if (expressionType.isCompatibleWith(castType))
135                                 return true;
136                         else {
137                                 if (castType.isCompatibleWith(expressionType)) {
138                                         return true;
139                                 }
140                                 return false;
141                         }
142                 }
143                 if (castType.isInterface()) { // ----- (castTb.isInterface) expressionTb.isClass -------  
144                         if (((ReferenceBinding) expressionType).isFinal()) { //no subclass for expressionTb, thus compile-time check is valid
145                                 if (expressionType.isCompatibleWith(castType))
146                                         return true;
147                                 return false;
148                         } else {
149                                 return true;
150                         }
151                 }
152
153                 return false;
154         }
155         if (expressionType.isInterface()) {
156                 if (castType.isArrayType()) { // ----- (castTb.isArray) expressionTb.isInterface ------
157                         if (scope.isJavaLangCloneable(expressionType) || scope.isJavaIoSerializable(expressionType))
158                                 //potential runtime error
159                                 {
160                                 return true;
161                         }
162                         return false;
163                 }
164                 if (castType.isBaseType()) {
165                         return false;
166                 }
167                 if (castType.isClass()) { // ----- (castTb.isClass) expressionTb.isInterface --------
168                         if (scope.isJavaLangObject(castType))
169                                 return true;
170                         if (((ReferenceBinding) castType).isFinal()) { //no subclass for castTb, thus compile-time check is valid
171                                 if (castType.isCompatibleWith(expressionType)) {
172                                         return true;
173                                 }
174                                 return false;
175                         }
176                         return true;
177                 }
178                 if (castType.isInterface()) { // ----- (castTb.isInterface) expressionTb.isInterface -------
179                         if (Scope.compareTypes(castType, expressionType) == NotRelated) {
180                                 MethodBinding[] castTbMethods = ((ReferenceBinding) castType).methods();
181                                 int castTbMethodsLength = castTbMethods.length;
182                                 MethodBinding[] expressionTbMethods = ((ReferenceBinding) expressionType).methods();
183                                 int expressionTbMethodsLength = expressionTbMethods.length;
184                                 for (int i = 0; i < castTbMethodsLength; i++) {
185                                         for (int j = 0; j < expressionTbMethodsLength; j++) {
186                                                 if (castTbMethods[i].selector == expressionTbMethods[j].selector) {
187                                                         if (castTbMethods[i].returnType != expressionTbMethods[j].returnType) {
188                                                                 if (castTbMethods[i].areParametersEqual(expressionTbMethods[j])) {
189                                                                         return false;
190                                                                 }
191                                                         }
192                                                 }
193                                         }
194                                 }
195                         }
196                         return true;
197                 }
198
199                 return false;
200         }
201
202         return false;
203 }
204 public final void computeConstant(TypeBinding leftType, TypeBinding rightType) {
205         if ((this.left.constant != NotAConstant) && (this.right.constant != NotAConstant)) {
206                 this.constant =
207                         Constant.computeConstantOperationEQUAL_EQUAL(
208                                 left.constant,
209                                 leftType.id,
210                                 EQUAL_EQUAL,
211                                 right.constant,
212                                 rightType.id);
213                 if (((this.bits & OperatorMASK) >> OperatorSHIFT) == NOT_EQUAL)
214                         constant = Constant.fromValue(!constant.booleanValue());
215         } else {
216                 this.constant = NotAConstant;
217                 // no optimization for null == null
218         }
219 }
220 /**
221  * Normal == or != code generation.
222  *
223  * @param currentScope org.eclipse.jdt.internal.compiler.lookup.BlockScope
224  * @param codeStream org.eclipse.jdt.internal.compiler.codegen.CodeStream
225  * @param valueRequired boolean
226  */
227 //public void generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired) {
228 //
229 //      if (constant != NotAConstant) {
230 //              int pc = codeStream.position;
231 //              if (valueRequired) 
232 //                      codeStream.generateConstant(constant, implicitConversion);
233 //              codeStream.recordPositionsFrom(pc, this.sourceStart);
234 //              return;
235 //      }
236 //      Label falseLabel;
237 //      bits |= OnlyValueRequiredMASK;
238 //      generateOptimizedBoolean(
239 //              currentScope, 
240 //              codeStream, 
241 //              null, 
242 //              falseLabel = new Label(codeStream), 
243 //              valueRequired);
244 //      if (falseLabel.hasForwardReferences()) {
245 //              if (valueRequired){
246 //                      // comparison is TRUE 
247 //                      codeStream.iconst_1();
248 //                      if ((bits & ValueForReturnMASK) != 0){
249 //                              codeStream.ireturn();
250 //                              // comparison is FALSE
251 //                              falseLabel.place();
252 //                              codeStream.iconst_0();
253 //                      } else {
254 //                              Label endLabel = new Label(codeStream);
255 //                              codeStream.goto_(endLabel);
256 //                              codeStream.decrStackSize(1);
257 //                              // comparison is FALSE
258 //                              falseLabel.place();
259 //                              codeStream.iconst_0();
260 //                              endLabel.place();
261 //                      }
262 //              } else {
263 //                      falseLabel.place();
264 //              }       
265 //      }
266 //}
267 /**
268  * Boolean operator code generation
269  *      Optimized operations are: == and !=
270  */
271 //public void generateOptimizedBoolean(BlockScope currentScope, CodeStream codeStream, Label trueLabel, Label falseLabel, boolean valueRequired) {
272 //
273 //      if (constant != Constant.NotAConstant) {
274 //              super.generateOptimizedBoolean(currentScope, codeStream, trueLabel, falseLabel, valueRequired);
275 //              return;
276 //      }
277 //      if (((bits & OperatorMASK) >> OperatorSHIFT) == EQUAL_EQUAL) {
278 //              if ((left.implicitConversion & 0xF) /*compile-time*/ == T_boolean) {
279 //                      generateOptimizedBooleanEqual(currentScope, codeStream, trueLabel, falseLabel, valueRequired);
280 //              } else {
281 //                      generateOptimizedNonBooleanEqual(currentScope, codeStream, trueLabel, falseLabel, valueRequired);
282 //              }
283 //      } else {
284 //              if ((left.implicitConversion & 0xF) /*compile-time*/ == T_boolean) {
285 //                      generateOptimizedBooleanEqual(currentScope, codeStream, falseLabel, trueLabel, valueRequired);
286 //              } else {
287 //                      generateOptimizedNonBooleanEqual(currentScope, codeStream, falseLabel, trueLabel, valueRequired);
288 //              }
289 //      }
290 //}
291 /**
292  * Boolean generation for == with boolean operands
293  *
294  * Note this code does not optimize conditional constants !!!!
295  */
296 //public void generateOptimizedBooleanEqual(BlockScope currentScope, CodeStream codeStream, Label trueLabel, Label falseLabel, boolean valueRequired) {
297 //
298 //      // optimized cases: true == x, false == x
299 //      if (left.constant != NotAConstant) {
300 //              boolean inline = left.constant.booleanValue();
301 //              right.generateOptimizedBoolean(currentScope, codeStream, (inline ? trueLabel : falseLabel), (inline ? falseLabel : trueLabel), valueRequired);
302 //              return;
303 //      } // optimized cases: x == true, x == false
304 //      if (right.constant != NotAConstant) {
305 //              boolean inline = right.constant.booleanValue();
306 //              left.generateOptimizedBoolean(currentScope, codeStream, (inline ? trueLabel : falseLabel), (inline ? falseLabel : trueLabel), valueRequired);
307 //              return;
308 //      }
309 //      // default case
310 //      left.generateCode(currentScope, codeStream, valueRequired);
311 //      right.generateCode(currentScope, codeStream, valueRequired);
312 //      if (valueRequired) {
313 //              if (falseLabel == null) {
314 //                      if (trueLabel != null) {
315 //                              // implicit falling through the FALSE case
316 //                              codeStream.if_icmpeq(trueLabel);
317 //                      }
318 //              } else {
319 //                      // implicit falling through the TRUE case
320 //                      if (trueLabel == null) {
321 //                              codeStream.if_icmpne(falseLabel);
322 //                      } else {
323 //                              // no implicit fall through TRUE/FALSE --> should never occur
324 //                      }
325 //              }
326 //      }
327 //      // reposition the endPC
328 //      codeStream.updateLastRecordedEndPC(codeStream.position);                                        
329 //}
330 ///**
331 // * Boolean generation for == with non-boolean operands
332 // *
333 // */
334 //public void generateOptimizedNonBooleanEqual(BlockScope currentScope, CodeStream codeStream, Label trueLabel, Label falseLabel, boolean valueRequired) {
335 //
336 //      int pc = codeStream.position;
337 //      Constant inline;
338 //      if ((inline = right.constant) != NotAConstant) {
339 //              // optimized case: x == 0
340 //              if (((left.implicitConversion >> 4) == T_int) && (inline.intValue() == 0)) {
341 //                      left.generateCode(currentScope, codeStream, valueRequired);
342 //                      if (valueRequired) {
343 //                              if (falseLabel == null) {
344 //                                      if (trueLabel != null) {
345 //                                              // implicit falling through the FALSE case
346 //                                              codeStream.ifeq(trueLabel);
347 //                                      }
348 //                              } else {
349 //                                      // implicit falling through the TRUE case
350 //                                      if (trueLabel == null) {
351 //                                              codeStream.ifne(falseLabel);
352 //                                      } else {
353 //                                              // no implicit fall through TRUE/FALSE --> should never occur
354 //                                      }
355 //                              }
356 //                      }
357 //                      codeStream.recordPositionsFrom(pc, this.sourceStart);
358 //                      return;
359 //              }
360 //      }
361 //      if ((inline = left.constant) != NotAConstant) {
362 //              // optimized case: 0 == x
363 //              if (((left.implicitConversion >> 4) == T_int)
364 //                      && (inline.intValue() == 0)) {
365 //                      right.generateCode(currentScope, codeStream, valueRequired);
366 //                      if (valueRequired) {
367 //                              if (falseLabel == null) {
368 //                                      if (trueLabel != null) {
369 //                                              // implicit falling through the FALSE case
370 //                                              codeStream.ifeq(trueLabel);
371 //                                      }
372 //                              } else {
373 //                                      // implicit falling through the TRUE case
374 //                                      if (trueLabel == null) {
375 //                                              codeStream.ifne(falseLabel);
376 //                                      } else {
377 //                                              // no implicit fall through TRUE/FALSE --> should never occur
378 //                                      }
379 //                              }
380 //                      }
381 //                      codeStream.recordPositionsFrom(pc, this.sourceStart);
382 //                      return;
383 //              }
384 //      }
385 //      // null cases
386 //      // optimized case: x == null
387 //      if (right instanceof NullLiteral) {
388 //              if (left instanceof NullLiteral) {
389 //                      // null == null
390 //                      if (valueRequired) {
391 //                                      if ((bits & OnlyValueRequiredMASK) != 0) {
392 //                                              if (((bits & OperatorMASK) >> OperatorSHIFT) == EQUAL_EQUAL) {
393 //                                                      codeStream.iconst_1();
394 //                                              } else {
395 //                                                      codeStream.iconst_0();
396 //                                              }
397 //                                      } else {
398 //                                              if (falseLabel == null) {
399 //                                                      // implicit falling through the FALSE case
400 //                                                      if (trueLabel != null) {
401 //                                                              codeStream.goto_(trueLabel);
402 //                                                      }
403 //                                              }
404 //                              }
405 //                      }
406 //              } else {
407 //                      left.generateCode(currentScope, codeStream, valueRequired);
408 //                      if (valueRequired) {
409 //                              if (falseLabel == null) {
410 //                                      if (trueLabel != null) {
411 //                                              // implicit falling through the FALSE case
412 //                                              codeStream.ifnull(trueLabel);
413 //                                      }
414 //                              } else {
415 //                                      // implicit falling through the TRUE case
416 //                                      if (trueLabel == null) {
417 //                                              codeStream.ifnonnull(falseLabel);
418 //                                      } else {
419 //                                              // no implicit fall through TRUE/FALSE --> should never occur
420 //                                      }
421 //                              }
422 //                      }
423 //              }
424 //              codeStream.recordPositionsFrom(pc, this.sourceStart);
425 //              return;
426 //      } else if (left instanceof NullLiteral) { // optimized case: null == x
427 //              right.generateCode(currentScope, codeStream, valueRequired);
428 //              if (valueRequired) {
429 //                      if (falseLabel == null) {
430 //                              if (trueLabel != null) {
431 //                                      // implicit falling through the FALSE case
432 //                                      codeStream.ifnull(trueLabel);
433 //                              }
434 //                      } else {
435 //                              // implicit falling through the TRUE case
436 //                              if (trueLabel == null) {
437 //                                      codeStream.ifnonnull(falseLabel);
438 //                              } else {
439 //                                      // no implicit fall through TRUE/FALSE --> should never occur
440 //                              }
441 //                      }
442 //              }
443 //              codeStream.recordPositionsFrom(pc, this.sourceStart);
444 //              return;
445 //      }
446 //
447 //      // default case
448 //      left.generateCode(currentScope, codeStream, valueRequired);
449 //      right.generateCode(currentScope, codeStream, valueRequired);
450 //      if (valueRequired) {
451 //              if (falseLabel == null) {
452 //                      if (trueLabel != null) {
453 //                              // implicit falling through the FALSE case
454 //                              switch (left.implicitConversion >> 4) { // operand runtime type
455 //                                      case T_int :
456 //                                              codeStream.if_icmpeq(trueLabel);
457 //                                              break;
458 //                                      case T_float :
459 //                                              codeStream.fcmpl();
460 //                                              codeStream.ifeq(trueLabel);
461 //                                              break;
462 //                                      case T_long :
463 //                                              codeStream.lcmp();
464 //                                              codeStream.ifeq(trueLabel);
465 //                                              break;
466 //                                      case T_double :
467 //                                              codeStream.dcmpl();
468 //                                              codeStream.ifeq(trueLabel);
469 //                                              break;
470 //                                      default :
471 //                                              codeStream.if_acmpeq(trueLabel);
472 //                              }
473 //                      }
474 //              } else {
475 //                      // implicit falling through the TRUE case
476 //                      if (trueLabel == null) {
477 //                              switch (left.implicitConversion >> 4) { // operand runtime type
478 //                                      case T_int :
479 //                                              codeStream.if_icmpne(falseLabel);
480 //                                              break;
481 //                                      case T_float :
482 //                                              codeStream.fcmpl();
483 //                                              codeStream.ifne(falseLabel);
484 //                                              break;
485 //                                      case T_long :
486 //                                              codeStream.lcmp();
487 //                                              codeStream.ifne(falseLabel);
488 //                                              break;
489 //                                      case T_double :
490 //                                              codeStream.dcmpl();
491 //                                              codeStream.ifne(falseLabel);
492 //                                              break;
493 //                                      default :
494 //                                              codeStream.if_acmpne(falseLabel);
495 //                              }
496 //                      } else {
497 //                              // no implicit fall through TRUE/FALSE --> should never occur
498 //                      }
499 //              }
500 //      }
501 //      codeStream.recordPositionsFrom(pc, this.sourceStart);
502 //}
503 public boolean isCompactableOperation() {
504         return false;
505 }
506 public TypeBinding resolveType(BlockScope scope) {
507         // always return BooleanBinding
508         TypeBinding leftType = left.resolveType(scope);
509         TypeBinding rightType = right.resolveType(scope);
510         if (leftType == null || rightType == null){
511                 constant = NotAConstant;                
512                 return null;
513         }
514
515         // both base type
516         if (leftType.isBaseType() && rightType.isBaseType()) {
517                 // the code is an int
518                 // (cast)  left   == (cast)  rigth --> result
519                 //  0000   0000       0000   0000      0000
520                 //  <<16   <<12       <<8    <<4       <<0
521                 int result = ResolveTypeTables[EQUAL_EQUAL][ (leftType.id << 4) + rightType.id];
522                 left.implicitConversion = result >>> 12;
523                 right.implicitConversion = (result >>> 4) & 0x000FF;
524                 bits |= result & 0xF;           
525                 if ((result & 0x0000F) == T_undefined) {
526                         constant = Constant.NotAConstant;
527                         scope.problemReporter().invalidOperator(this, leftType, rightType);
528                         return null;
529                 }
530                 computeConstant(leftType, rightType);
531                 this.resolvedType = BooleanBinding;
532                 return BooleanBinding;
533         }
534
535         // Object references 
536         // spec 15.20.3
537         if (areTypesCastCompatible(scope, rightType, leftType) || areTypesCastCompatible(scope, leftType, rightType)) {
538                 // (special case for String)
539                 if ((rightType.id == T_String) && (leftType.id == T_String))
540                         computeConstant(leftType, rightType);
541                 else
542                         constant = NotAConstant;
543                 if (rightType.id == T_String)
544                         right.implicitConversion = String2String;
545                 if (leftType.id == T_String)
546                         left.implicitConversion = String2String;
547                 this.resolvedType = BooleanBinding;
548                 return BooleanBinding;
549         }
550         constant = NotAConstant;
551         scope.problemReporter().notCompatibleTypesError(this, leftType, rightType);
552         return null;
553 }
554 public void traverse(IAbstractSyntaxTreeVisitor visitor, BlockScope scope) {
555         if (visitor.visit(this, scope)) {
556                 left.traverse(visitor, scope);
557                 right.traverse(visitor, scope);
558         }
559         visitor.endVisit(this, scope);
560 }
561 }