misc changes
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / compiler / ast / ConditionalExpression.java
1 /*******************************************************************************
2  * Copyright (c) 2000, 2001, 2002 International Business Machines Corp. and others.
3  * All rights reserved. This program and the accompanying materials 
4  * are made available under the terms of the Common Public License v0.5 
5  * which accompanies this distribution, and is available at
6  * http://www.eclipse.org/legal/cpl-v05.html
7  * 
8  * Contributors:
9  *     IBM Corporation - initial API and implementation
10  ******************************************************************************/
11 package net.sourceforge.phpdt.internal.compiler.ast;
12
13 import net.sourceforge.phpdt.internal.compiler.IAbstractSyntaxTreeVisitor;
14 import net.sourceforge.phpdt.internal.compiler.impl.*;
15 import net.sourceforge.phpdt.internal.compiler.codegen.*;
16 import net.sourceforge.phpdt.internal.compiler.flow.*;
17 import net.sourceforge.phpdt.internal.compiler.lookup.*;
18
19 public class ConditionalExpression extends OperatorExpression {
20
21         public Expression condition, valueIfTrue, valueIfFalse;
22         private int returnTypeSlotSize = 1;
23
24         // for local variables table attributes
25         int thenInitStateIndex = -1;
26         int elseInitStateIndex = -1;
27         int mergedInitStateIndex = -1;
28         
29         public ConditionalExpression(
30                 Expression condition,
31                 Expression valueIfTrue,
32                 Expression valueIfFalse) {
33                 this.condition = condition;
34                 this.valueIfTrue = valueIfTrue;
35                 this.valueIfFalse = valueIfFalse;
36                 sourceStart = condition.sourceStart;
37                 sourceEnd = valueIfFalse.sourceEnd;
38         }
39
40         public FlowInfo analyseCode(
41                 BlockScope currentScope,
42                 FlowContext flowContext,
43                 FlowInfo flowInfo) {
44
45                 Constant conditionConstant = condition.conditionalConstant();
46
47                 flowInfo = condition.analyseCode(currentScope, flowContext, flowInfo, conditionConstant == NotAConstant);
48
49                 if (conditionConstant != NotAConstant) {
50                         if (conditionConstant.booleanValue() == true) {
51                                 // TRUE ? left : right
52                                 FlowInfo resultInfo =
53                                         valueIfTrue.analyseCode(currentScope, flowContext, flowInfo.initsWhenTrue().unconditionalInits());
54                                 // analyse valueIfFalse, but do not take into account any of its infos
55                                 valueIfFalse.analyseCode(
56                                         currentScope,
57                                         flowContext,
58                                         flowInfo.initsWhenFalse().copy().unconditionalInits().markAsFakeReachable(true));
59                                 mergedInitStateIndex =
60                                         currentScope.methodScope().recordInitializationStates(resultInfo);
61                                 return resultInfo;
62                         } else {
63                                 // FALSE ? left : right
64                                 // analyse valueIfTrue, but do not take into account any of its infos                   
65                                 valueIfTrue.analyseCode(
66                                         currentScope,
67                                         flowContext,
68                                         flowInfo.initsWhenTrue().copy().unconditionalInits().markAsFakeReachable(true));
69                                 FlowInfo mergeInfo =
70                                         valueIfFalse.analyseCode(currentScope, flowContext, flowInfo.initsWhenFalse().unconditionalInits());
71                                 mergedInitStateIndex =
72                                         currentScope.methodScope().recordInitializationStates(mergeInfo);
73                                 return mergeInfo;
74                         }
75                 }
76
77                 // store a copy of the merged info, so as to compute the local variable attributes afterwards
78                 FlowInfo trueInfo = flowInfo.initsWhenTrue();
79                 thenInitStateIndex =
80                         currentScope.methodScope().recordInitializationStates(trueInfo);
81                 FlowInfo falseInfo = flowInfo.initsWhenFalse();
82                 elseInitStateIndex =
83                         currentScope.methodScope().recordInitializationStates(falseInfo);
84
85                 // propagate analysis
86                 trueInfo = valueIfTrue.analyseCode(currentScope, flowContext, trueInfo.copy());
87                 falseInfo =
88                         valueIfFalse.analyseCode(currentScope, flowContext, falseInfo.copy());
89
90                 // merge back using a conditional info -  1GK2BLM
91                 // if ((t && (v = t)) ? t : t && (v = f)) r = v;  -- ok
92                 FlowInfo mergedInfo =
93                         FlowInfo.conditional(
94                                 trueInfo.initsWhenTrue().copy().unconditionalInits().mergedWith( // must copy, since could be shared with trueInfo.initsWhenFalse()...
95                                         falseInfo.initsWhenTrue().copy().unconditionalInits()),
96                                 trueInfo.initsWhenFalse().unconditionalInits().mergedWith(
97                                         falseInfo.initsWhenFalse().unconditionalInits()));
98                 /*                      
99                         FlowInfo mergedInfo = valueIfTrue.analyseCode(
100                                 currentScope,
101                                 flowContext,
102                                 flowInfo.initsWhenTrue().copy()).
103                                         unconditionalInits().
104                                                 mergedWith(
105                                                         valueIfFalse.analyseCode(
106                                                                 currentScope,
107                                                                 flowContext,
108                                                                 flowInfo.initsWhenFalse().copy()).
109                                                                         unconditionalInits());
110                 */
111                 mergedInitStateIndex =
112                         currentScope.methodScope().recordInitializationStates(mergedInfo);
113                 return mergedInfo;
114         }
115
116         /**
117          * Code generation for the conditional operator ?:
118          *
119          * @param currentScope org.eclipse.jdt.internal.compiler.lookup.BlockScope
120          * @param codeStream org.eclipse.jdt.internal.compiler.codegen.CodeStream
121          * @param valueRequired boolean
122         */
123         public void generateCode(
124                 BlockScope currentScope,
125                 CodeStream codeStream,
126                 boolean valueRequired) {
127
128                 int pc = codeStream.position;
129                 Label endifLabel, falseLabel;
130                 if (constant != NotAConstant) {
131                         if (valueRequired)
132                                 codeStream.generateConstant(constant, implicitConversion);
133                         codeStream.recordPositionsFrom(pc, this.sourceStart);
134                         return;
135                 }
136                 Constant cst = condition.constant;
137                 Constant condCst = condition.conditionalConstant();
138                 boolean needTruePart =
139                         !(((cst != NotAConstant) && (cst.booleanValue() == false))
140                                 || ((condCst != NotAConstant) && (condCst.booleanValue() == false)));
141                 boolean needFalsePart =
142                         !(((cst != NotAConstant) && (cst.booleanValue() == true))
143                                 || ((condCst != NotAConstant) && (condCst.booleanValue() == true)));
144                 endifLabel = new Label(codeStream);
145
146                 // Generate code for the condition
147                 boolean needConditionValue = (cst == NotAConstant) && (condCst == NotAConstant);
148                 condition.generateOptimizedBoolean(
149                         currentScope,
150                         codeStream,
151                         null,
152                         (falseLabel = new Label(codeStream)),
153                         needConditionValue);
154
155                 if (thenInitStateIndex != -1) {
156                         codeStream.removeNotDefinitelyAssignedVariables(
157                                 currentScope,
158                                 thenInitStateIndex);
159                         codeStream.addDefinitelyAssignedVariables(currentScope, thenInitStateIndex);
160                 }
161                 // Then code generation
162                 if (needTruePart) {
163                         valueIfTrue.generateCode(currentScope, codeStream, valueRequired);
164                         if (needFalsePart) {
165                                 // Jump over the else part
166                                 int position = codeStream.position;
167                                 codeStream.goto_(endifLabel);
168                                 codeStream.updateLastRecordedEndPC(position);
169                                 // Tune codestream stack size
170                                 if (valueRequired) {
171                                         codeStream.decrStackSize(returnTypeSlotSize);
172                                 }
173                         }
174                 }
175                 if (needFalsePart) {
176                         falseLabel.place();
177                         if (elseInitStateIndex != -1) {
178                                 codeStream.removeNotDefinitelyAssignedVariables(
179                                         currentScope,
180                                         elseInitStateIndex);
181                                 codeStream.addDefinitelyAssignedVariables(currentScope, elseInitStateIndex);
182                         }
183                         valueIfFalse.generateCode(currentScope, codeStream, valueRequired);
184                         // End of if statement
185                         endifLabel.place();
186                 }
187                 // May loose some local variable initializations : affecting the local variable attributes
188                 if (mergedInitStateIndex != -1) {
189                         codeStream.removeNotDefinitelyAssignedVariables(
190                                 currentScope,
191                                 mergedInitStateIndex);
192                 }
193                 // implicit conversion
194                 if (valueRequired)
195                         codeStream.generateImplicitConversion(implicitConversion);
196                 codeStream.recordPositionsFrom(pc, this.sourceStart);
197         }
198
199         /**
200          * Optimized boolean code generation for the conditional operator ?:
201         */
202         public void generateOptimizedBoolean(
203                 BlockScope currentScope,
204                 CodeStream codeStream,
205                 Label trueLabel,
206                 Label falseLabel,
207                 boolean valueRequired) {
208
209                 if ((constant != Constant.NotAConstant) && (constant.typeID() == T_boolean) // constant
210                         || (valueIfTrue.implicitConversion >> 4) != T_boolean) { // non boolean values
211                         super.generateOptimizedBoolean(currentScope, codeStream, trueLabel, falseLabel, valueRequired);
212                         return;
213                 }
214                 int pc = codeStream.position;
215                 Constant cst = condition.constant;
216                 Constant condCst = condition.conditionalConstant();
217                 boolean needTruePart =
218                         !(((cst != NotAConstant) && (cst.booleanValue() == false))
219                                 || ((condCst != NotAConstant) && (condCst.booleanValue() == false)));
220                 boolean needFalsePart =
221                         !(((cst != NotAConstant) && (cst.booleanValue() == true))
222                                 || ((condCst != NotAConstant) && (condCst.booleanValue() == true)));
223
224                 Label internalFalseLabel, endifLabel = new Label(codeStream);
225
226                 // Generate code for the condition
227                 boolean needConditionValue = (cst == NotAConstant) && (condCst == NotAConstant);
228                 condition.generateOptimizedBoolean(
229                                 currentScope,
230                                 codeStream,
231                                 null,
232                                 internalFalseLabel = new Label(codeStream),
233                                 needConditionValue);
234
235                 if (thenInitStateIndex != -1) {
236                         codeStream.removeNotDefinitelyAssignedVariables(
237                                 currentScope,
238                                 thenInitStateIndex);
239                         codeStream.addDefinitelyAssignedVariables(currentScope, thenInitStateIndex);
240                 }
241                 // Then code generation
242                 if (needTruePart) {
243                         valueIfTrue.generateOptimizedBoolean(currentScope, codeStream, trueLabel, falseLabel, valueRequired);
244                         
245                         if (needFalsePart) {
246                                 // Jump over the else part
247                                 int position = codeStream.position;
248                                 codeStream.goto_(endifLabel);
249                                 codeStream.updateLastRecordedEndPC(position);
250                                 // Tune codestream stack size
251                                 //if (valueRequired) {
252                                 //      codeStream.decrStackSize(returnTypeSlotSize);
253                                 //}
254                         }
255                 }
256                 if (needFalsePart) {
257                         internalFalseLabel.place();
258                         if (elseInitStateIndex != -1) {
259                                 codeStream.removeNotDefinitelyAssignedVariables(
260                                         currentScope,
261                                         elseInitStateIndex);
262                                 codeStream.addDefinitelyAssignedVariables(currentScope, elseInitStateIndex);
263                         }
264                         valueIfFalse.generateOptimizedBoolean(currentScope, codeStream, trueLabel, falseLabel, valueRequired);
265
266                         // End of if statement
267                         endifLabel.place();
268                 }
269                 // May loose some local variable initializations : affecting the local variable attributes
270                 if (mergedInitStateIndex != -1) {
271                         codeStream.removeNotDefinitelyAssignedVariables(
272                                 currentScope,
273                                 mergedInitStateIndex);
274                 }
275                 // no implicit conversion for boolean values
276                 codeStream.recordPositionsFrom(pc, this.sourceStart);
277         }
278
279         public TypeBinding resolveType(BlockScope scope) {
280                 // specs p.368
281                 constant = NotAConstant;
282                 TypeBinding conditionType = condition.resolveTypeExpecting(scope, BooleanBinding);
283                 TypeBinding valueIfTrueType = valueIfTrue.resolveType(scope);
284                 TypeBinding valueIfFalseType = valueIfFalse.resolveType(scope);
285                 if (conditionType == null || valueIfTrueType == null || valueIfFalseType == null)
286                         return null;
287
288                 // Propagate the constant value from the valueIfTrue and valueIFFalse expression if it is possible
289                 if (condition.constant != NotAConstant
290                         && valueIfTrue.constant != NotAConstant
291                         && valueIfFalse.constant != NotAConstant) {
292                         // all terms are constant expression so we can propagate the constant
293                         // from valueIFTrue or valueIfFalse to teh receiver constant
294                         constant =
295                                 (condition.constant.booleanValue())
296                                         ? valueIfTrue.constant
297                                         : valueIfFalse.constant;
298                 }
299                 if (valueIfTrueType == valueIfFalseType) { // harmed the implicit conversion 
300                         valueIfTrue.implicitWidening(valueIfTrueType, valueIfTrueType);
301                         valueIfFalse.implicitConversion = valueIfTrue.implicitConversion;
302                         if (valueIfTrueType == LongBinding || valueIfTrueType == DoubleBinding) {
303                                 returnTypeSlotSize = 2;
304                         }
305                         this.typeBinding = valueIfTrueType;
306                         return valueIfTrueType;
307                 }
308                 // Determine the return type depending on argument types
309                 // Numeric types
310                 if (valueIfTrueType.isNumericType() && valueIfFalseType.isNumericType()) {
311                         // (Short x Byte) or (Byte x Short)"
312                         if ((valueIfTrueType == ByteBinding && valueIfFalseType == ShortBinding)
313                                 || (valueIfTrueType == ShortBinding && valueIfFalseType == ByteBinding)) {
314                                 valueIfTrue.implicitWidening(ShortBinding, valueIfTrueType);
315                                 valueIfFalse.implicitWidening(ShortBinding, valueIfFalseType);
316                                 this.typeBinding = ShortBinding;
317                                 return ShortBinding;
318                         }
319                         // <Byte|Short|Char> x constant(Int)  ---> <Byte|Short|Char>   and reciprocally
320                         if ((valueIfTrueType == ByteBinding || valueIfTrueType == ShortBinding || valueIfTrueType == CharBinding)
321                                 && (valueIfFalseType == IntBinding
322                                         && valueIfFalse.isConstantValueOfTypeAssignableToType(valueIfFalseType, valueIfTrueType))) {
323                                 valueIfTrue.implicitWidening(valueIfTrueType, valueIfTrueType);
324                                 valueIfFalse.implicitWidening(valueIfTrueType, valueIfFalseType);
325                                 this.typeBinding = valueIfTrueType;
326                                 return valueIfTrueType;
327                         }
328                         if ((valueIfFalseType == ByteBinding
329                                 || valueIfFalseType == ShortBinding
330                                 || valueIfFalseType == CharBinding)
331                                 && (valueIfTrueType == IntBinding
332                                         && valueIfTrue.isConstantValueOfTypeAssignableToType(valueIfTrueType, valueIfFalseType))) {
333                                 valueIfTrue.implicitWidening(valueIfFalseType, valueIfTrueType);
334                                 valueIfFalse.implicitWidening(valueIfFalseType, valueIfFalseType);
335                                 this.typeBinding = valueIfFalseType;
336                                 return valueIfFalseType;
337                         }
338                         // Manual binary numeric promotion
339                         // int
340                         if (BaseTypeBinding.isNarrowing(valueIfTrueType.id, T_int)
341                                 && BaseTypeBinding.isNarrowing(valueIfFalseType.id, T_int)) {
342                                 valueIfTrue.implicitWidening(IntBinding, valueIfTrueType);
343                                 valueIfFalse.implicitWidening(IntBinding, valueIfFalseType);
344                                 this.typeBinding = IntBinding;
345                                 return IntBinding;
346                         }
347                         // long
348                         if (BaseTypeBinding.isNarrowing(valueIfTrueType.id, T_long)
349                                 && BaseTypeBinding.isNarrowing(valueIfFalseType.id, T_long)) {
350                                 valueIfTrue.implicitWidening(LongBinding, valueIfTrueType);
351                                 valueIfFalse.implicitWidening(LongBinding, valueIfFalseType);
352                                 returnTypeSlotSize = 2;
353                                 this.typeBinding = LongBinding;
354                                 return LongBinding;
355                         }
356                         // float
357                         if (BaseTypeBinding.isNarrowing(valueIfTrueType.id, T_float)
358                                 && BaseTypeBinding.isNarrowing(valueIfFalseType.id, T_float)) {
359                                 valueIfTrue.implicitWidening(FloatBinding, valueIfTrueType);
360                                 valueIfFalse.implicitWidening(FloatBinding, valueIfFalseType);
361                                 this.typeBinding = FloatBinding;
362                                 return FloatBinding;
363                         }
364                         // double
365                         valueIfTrue.implicitWidening(DoubleBinding, valueIfTrueType);
366                         valueIfFalse.implicitWidening(DoubleBinding, valueIfFalseType);
367                         returnTypeSlotSize = 2;
368                         this.typeBinding = DoubleBinding;
369                         return DoubleBinding;
370                 }
371                 // Type references (null null is already tested)
372                 if ((valueIfTrueType.isBaseType() && valueIfTrueType != NullBinding)
373                         || (valueIfFalseType.isBaseType() && valueIfFalseType != NullBinding)) {
374                         scope.problemReporter().conditionalArgumentsIncompatibleTypes(
375                                 this,
376                                 valueIfTrueType,
377                                 valueIfFalseType);
378                         return null;
379                 }
380                 if (scope.areTypesCompatible(valueIfFalseType, valueIfTrueType)) {
381                         valueIfTrue.implicitWidening(valueIfTrueType, valueIfTrueType);
382                         valueIfFalse.implicitWidening(valueIfTrueType, valueIfFalseType);
383                         this.typeBinding = valueIfTrueType;
384                         return valueIfTrueType;
385                 }
386                 if (scope.areTypesCompatible(valueIfTrueType, valueIfFalseType)) {
387                         valueIfTrue.implicitWidening(valueIfFalseType, valueIfTrueType);
388                         valueIfFalse.implicitWidening(valueIfFalseType, valueIfFalseType);
389                         this.typeBinding = valueIfFalseType;
390                         return valueIfFalseType;
391                 }
392                 scope.problemReporter().conditionalArgumentsIncompatibleTypes(
393                         this,
394                         valueIfTrueType,
395                         valueIfFalseType);
396                 return null;
397         }
398         
399         public String toStringExpressionNoParenthesis() {
400                 return condition.toStringExpression() + " ? " + //$NON-NLS-1$
401                 valueIfTrue.toStringExpression() + " : " + //$NON-NLS-1$
402                 valueIfFalse.toStringExpression();
403         }
404
405         public void traverse(IAbstractSyntaxTreeVisitor visitor, BlockScope scope) {
406                 if (visitor.visit(this, scope)) {
407                         condition.traverse(visitor, scope);
408                         valueIfTrue.traverse(visitor, scope);
409                         valueIfFalse.traverse(visitor, scope);
410                 }
411                 visitor.endVisit(this, scope);
412         }
413 }