request 1152810, implementing formatting of array initializers
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / compiler / ast / CastExpression.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.phpdt.internal.compiler.ast;
12
13 import net.sourceforge.phpdt.internal.compiler.ASTVisitor;
14 import net.sourceforge.phpdt.internal.compiler.flow.FlowContext;
15 import net.sourceforge.phpdt.internal.compiler.flow.FlowInfo;
16 import net.sourceforge.phpdt.internal.compiler.impl.Constant;
17 import net.sourceforge.phpdt.internal.compiler.lookup.ArrayBinding;
18 import net.sourceforge.phpdt.internal.compiler.lookup.BaseTypeBinding;
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 CastExpression extends Expression {
26
27         public Expression expression;
28         public Expression type;
29         public boolean needRuntimeCheckcast;
30
31         //expression.implicitConversion holds the cast for baseType casting 
32         public CastExpression(Expression e, Expression t) {
33                 expression = e;
34                 type = t;
35
36                 //due to the fact an expression may start with ( and that a cast also start with (
37                 //the field is an expression....it can be a TypeReference OR a NameReference Or
38                 //an expression <--this last one is invalid.......
39
40                 // :-( .............
41
42                 //if (type instanceof TypeReference )
43                 //      flag = IsTypeReference ;
44                 //else
45                 //      if (type instanceof NameReference)
46                 //              flag = IsNameReference ;
47                 //      else
48                 //              flag = IsExpression ;
49
50         }
51
52         public FlowInfo analyseCode(
53                 BlockScope currentScope,
54                 FlowContext flowContext,
55                 FlowInfo flowInfo) {
56
57                 return expression
58                         .analyseCode(currentScope, flowContext, flowInfo)
59                         .unconditionalInits();
60         }
61
62         public final void areTypesCastCompatible(
63                 BlockScope scope,
64                 TypeBinding castType,
65                 TypeBinding expressionType) {
66
67                 // see specifications 5.5
68                 // handle errors and process constant when needed
69
70                 // if either one of the type is null ==>
71                 // some error has been already reported some where ==>
72                 // we then do not report an obvious-cascade-error.
73
74                 needRuntimeCheckcast = false;
75                 if (castType == null || expressionType == null) return;
76
77                 // identity conversion cannot be performed upfront, due to side-effects
78                 // like constant propagation
79                                 
80                 if (castType.isBaseType()) {
81                         if (expressionType.isBaseType()) {
82                                 if (expressionType == castType) {
83                                         expression.implicitWidening(castType, expressionType);
84                                         constant = expression.constant; //use the same constant
85                                         return;
86                                 }
87                                 if (expressionType.isCompatibleWith(castType)
88                                         || BaseTypeBinding.isNarrowing(castType.id, expressionType.id)) {
89                                         expression.implicitConversion = (castType.id << 4) + expressionType.id;
90                                         if (expression.constant != Constant.NotAConstant)
91                                                 constant = expression.constant.castTo(expression.implicitConversion);
92                                         return;
93                                 }
94                         }
95                         scope.problemReporter().typeCastError(this, castType, expressionType);
96                         return;
97                 }
98
99                 //-----------cast to something which is NOT a base type--------------------------       
100                 if (expressionType == NullBinding) {
101                         //      if (castType.isArrayType()){ // 26903 - need checkcast when casting null to array type
102                         //              needRuntimeCheckcast = true;
103                         //      }
104                         return; //null is compatible with every thing
105                 }
106                 if (expressionType.isBaseType()) {
107                         scope.problemReporter().typeCastError(this, castType, expressionType);
108                         return;
109                 }
110
111                 if (expressionType.isArrayType()) {
112                         if (castType == expressionType) return; // identity conversion
113
114                         if (castType.isArrayType()) {
115                                 //------- (castType.isArray) expressionType.isArray -----------
116                                 TypeBinding exprElementType = ((ArrayBinding) expressionType).elementsType(scope);
117                                 if (exprElementType.isBaseType()) {
118                                         // <---stop the recursion------- 
119                                         if (((ArrayBinding) castType).elementsType(scope) == exprElementType)
120                                                 needRuntimeCheckcast = true;
121                                         else
122                                                 scope.problemReporter().typeCastError(this, castType, expressionType);
123                                         return;
124                                 }
125                                 // recursively on the elements...
126                                 areTypesCastCompatible(
127                                         scope,
128                                         ((ArrayBinding) castType).elementsType(scope),
129                                         exprElementType);
130                                 return;
131                         } else if (
132                                 castType.isClass()) {
133                                 //------(castType.isClass) expressionType.isArray ---------------       
134                                 if (scope.isJavaLangObject(castType))
135                                         return;
136                         } else { //------- (castType.isInterface) expressionType.isArray -----------
137                                 if (scope.isJavaLangCloneable(castType) || scope.isJavaIoSerializable(castType)) {
138                                         needRuntimeCheckcast = true;
139                                         return;
140                                 }
141                         }
142                         scope.problemReporter().typeCastError(this, castType, expressionType);
143                         return;
144                 }
145
146                 if (expressionType.isClass()) {
147                         if (castType.isArrayType()) {
148                                 // ---- (castType.isArray) expressionType.isClass -------
149                                 if (scope.isJavaLangObject(expressionType)) { // potential runtime error
150                                         needRuntimeCheckcast = true;
151                                         return;
152                                 }
153                         } else if (castType.isClass()) { // ----- (castType.isClass) expressionType.isClass ------
154                                 if (expressionType.isCompatibleWith(castType)){ // no runtime error
155                                         if (castType.id == T_String) constant = expression.constant; // (String) cst is still a constant
156                                         return;
157                                 }
158                                 if (castType.isCompatibleWith(expressionType)) {
159                                         // potential runtime  error
160                                         needRuntimeCheckcast = true;
161                                         return;
162                                 }
163                         } else { // ----- (castType.isInterface) expressionType.isClass -------  
164                                 if (((ReferenceBinding) expressionType).isFinal()) {
165                                         // no subclass for expressionType, thus compile-time check is valid
166                                         if (expressionType.isCompatibleWith(castType)) 
167                                                 return;
168                                 } else { // a subclass may implement the interface ==> no check at compile time
169                                         needRuntimeCheckcast = true;
170                                         return;
171                                 }
172                         }
173                         scope.problemReporter().typeCastError(this, castType, expressionType);
174                         return;
175                 }
176
177                 //      if (expressionType.isInterface()) { cannot be anything else
178                 if (castType.isArrayType()) {
179                         // ----- (castType.isArray) expressionType.isInterface ------
180                         if (scope.isJavaLangCloneable(expressionType)
181                                 || scope.isJavaIoSerializable(expressionType)) // potential runtime error
182                                 needRuntimeCheckcast = true;
183                         else
184                                 scope.problemReporter().typeCastError(this, castType, expressionType);
185                         return;
186                 } else if (castType.isClass()) { // ----- (castType.isClass) expressionType.isInterface --------
187                         if (scope.isJavaLangObject(castType)) // no runtime error
188                                 return;
189                         if (((ReferenceBinding) castType).isFinal()) {
190                                 // no subclass for castType, thus compile-time check is valid
191                                 if (!castType.isCompatibleWith(expressionType)) {
192                                         // potential runtime error
193                                         scope.problemReporter().typeCastError(this, castType, expressionType);
194                                         return;
195                                 }
196                         }
197                 } else { // ----- (castType.isInterface) expressionType.isInterface -------
198                         if (castType == expressionType) return; // identity conversion
199                         if (Scope.compareTypes(castType, expressionType) == NotRelated) {
200                                 MethodBinding[] castTypeMethods = ((ReferenceBinding) castType).methods();
201                                 MethodBinding[] expressionTypeMethods =
202                                         ((ReferenceBinding) expressionType).methods();
203                                 int exprMethodsLength = expressionTypeMethods.length;
204                                 for (int i = 0, castMethodsLength = castTypeMethods.length; i < castMethodsLength; i++)
205                                         for (int j = 0; j < exprMethodsLength; j++) {
206                                                 if ((castTypeMethods[i].returnType != expressionTypeMethods[j].returnType)
207                                                                 && (castTypeMethods[i].selector == expressionTypeMethods[j].selector)
208                                                                 && castTypeMethods[i].areParametersEqual(expressionTypeMethods[j])) {
209                                                         scope.problemReporter().typeCastError(this, castType, expressionType);
210                                                 }
211                                         }
212                         }
213                 }
214                 needRuntimeCheckcast = true;
215                 return;
216         }
217
218         /**
219          * Cast expression code generation
220          *
221          * @param currentScope net.sourceforge.phpdt.internal.compiler.lookup.BlockScope
222          * @param codeStream net.sourceforge.phpdt.internal.compiler.codegen.CodeStream
223          * @param valueRequired boolean
224          */
225 //      public void generateCode(
226 //              BlockScope currentScope,
227 //              CodeStream codeStream,
228 //              boolean valueRequired) {
229 //
230 //              int pc = codeStream.position;
231 //              if (constant != NotAConstant) {
232 //                      if (valueRequired
233 //                              || needRuntimeCheckcast) { // Added for: 1F1W9IG: IVJCOM:WINNT - Compiler omits casting check
234 //                              codeStream.generateConstant(constant, implicitConversion);
235 //                              if (needRuntimeCheckcast) {
236 //                                      codeStream.checkcast(this.resolvedType);
237 //                                      if (!valueRequired)
238 //                                              codeStream.pop();
239 //                              }
240 //                      }
241 //                      codeStream.recordPositionsFrom(pc, this.sourceStart);
242 //                      return;
243 //              }
244 //              expression.generateCode(
245 //                      currentScope,
246 //                      codeStream,
247 //                      valueRequired || needRuntimeCheckcast);
248 //              if (needRuntimeCheckcast) {
249 //                      codeStream.checkcast(this.resolvedType);
250 //                      if (!valueRequired)
251 //                              codeStream.pop();
252 //              } else {
253 //                      if (valueRequired)
254 //                              codeStream.generateImplicitConversion(implicitConversion);
255 //              }
256 //              codeStream.recordPositionsFrom(pc, this.sourceStart);
257 //      }
258
259         public Expression innermostCastedExpression(){ 
260                 Expression current = this.expression;
261                 while (current instanceof CastExpression) {
262                         current = ((CastExpression) current).expression;
263                 }
264                 return current;
265         }
266         public StringBuffer printExpression(int indent, StringBuffer output) {
267
268                 output.append('(');
269                 type.print(0, output).append(") "); //$NON-NLS-1$
270                 return expression.printExpression(0, output);
271         }
272
273         public TypeBinding resolveType(BlockScope scope) {
274                 // compute a new constant if the cast is effective
275
276                 // due to the fact an expression may start with ( and that a cast can also start with (
277                 // the field is an expression....it can be a TypeReference OR a NameReference Or
278                 // any kind of Expression <-- this last one is invalid.......
279
280                 constant = Constant.NotAConstant;
281                 implicitConversion = T_undefined;
282                 if ((type instanceof TypeReference) || (type instanceof NameReference)) {
283                         this.resolvedType = type.resolveType(scope);
284                         TypeBinding castedExpressionType = expression.resolveType(scope);
285                         if (this.resolvedType != null && castedExpressionType != null) {
286                                 areTypesCastCompatible(scope, this.resolvedType, castedExpressionType);
287                         }
288                         return this.resolvedType;
289                 } else { // expression as a cast !!!!!!!!
290                         TypeBinding castedExpressionType = expression.resolveType(scope);
291                         if (castedExpressionType == null) return null;
292                         scope.problemReporter().invalidTypeReference(type);
293                         return null;
294                 }
295         }
296
297         public String toStringExpression() {
298
299                 return "(" + type.toString(0) + ") " + //$NON-NLS-2$ //$NON-NLS-1$
300                 expression.toStringExpression();
301         }
302
303         public void traverse(
304             ASTVisitor visitor,
305                 BlockScope blockScope) {
306
307                 if (visitor.visit(this, blockScope)) {
308                         type.traverse(visitor, blockScope);
309                         expression.traverse(visitor, blockScope);
310                 }
311                 visitor.endVisit(this, blockScope);
312         }
313 }