Replace deprecated org.eclipse.core.runtime.Platform.Run with org.eclipse.core.runtim...
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / compiler / ast / MemberValuePair.java
1 /*******************************************************************************
2  * Copyright (c) 2000, 2008 IBM Corporation and others.
3  * All rights reserved. This program and the accompanying materials
4  * are made available under the terms of the Eclipse Public License v1.0
5  * which accompanies this distribution, and is available at
6  * http://www.eclipse.org/legal/epl-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.impl.Constant;
15 import net.sourceforge.phpdt.internal.compiler.lookup.BaseTypeBinding;
16 import net.sourceforge.phpdt.internal.compiler.lookup.Binding;
17 import net.sourceforge.phpdt.internal.compiler.lookup.BlockScope;
18 import net.sourceforge.phpdt.internal.compiler.lookup.ElementValuePair;
19 import net.sourceforge.phpdt.internal.compiler.lookup.FieldBinding;
20 import net.sourceforge.phpdt.internal.compiler.lookup.MethodBinding;
21 import net.sourceforge.phpdt.internal.compiler.lookup.TypeBinding;
22
23 /**
24  * MemberValuePair node
25  */
26 public class MemberValuePair extends ASTNode {
27         
28         public char[] name;
29         public Expression value;
30         public MethodBinding binding;
31         /** 
32          *  The representation of this pair in the type system. 
33          */
34         public ElementValuePair compilerElementPair = null;
35         
36         public MemberValuePair(char[] token, int sourceStart, int sourceEnd, Expression value) {
37                 this.name = token;
38                 this.sourceStart = sourceStart;
39                 this.sourceEnd = sourceEnd;
40                 this.value = value;
41                 if (value instanceof ArrayInitializer) {
42                         value.bits |= IsAnnotationDefaultValue;
43                 }
44         }
45         
46         /* (non-Javadoc)
47          * @see org.eclipse.jdt.internal.compiler.ast.ASTNode#print(int, java.lang.StringBuffer)
48          */
49         public StringBuffer print(int indent, StringBuffer output) {
50                 output
51                         .append(name)
52                         .append(" = "); //$NON-NLS-1$
53                 value.print(0, output);
54                 return output;
55         }
56         
57         public void resolveTypeExpecting(BlockScope scope, TypeBinding requiredType) {
58                 
59                 if (this.value == null) {
60                         this.compilerElementPair = new ElementValuePair(this.name, this.value, this.binding);
61                         return;
62                 }
63                 if (requiredType == null) {
64                         // fault tolerance: keep resolving
65                         if (this.value instanceof ArrayInitializer) {
66                                 this.value.resolveTypeExpecting(scope, null);
67                         } else {
68                                 this.value.resolveType(scope);
69                         }
70                         this.compilerElementPair = new ElementValuePair(this.name, this.value, this.binding);
71                         return;
72                 }
73
74                 this.value.setExpectedType(requiredType); // needed in case of generic method invocation
75                 TypeBinding valueType;
76                 if (this.value instanceof ArrayInitializer) {
77                         ArrayInitializer initializer = (ArrayInitializer) this.value;
78                         valueType = initializer.resolveTypeExpecting(scope, this.binding.returnType);
79                 } else if (this.value instanceof ArrayAllocationExpression) {
80                         scope.problemReporter().annotationValueMustBeArrayInitializer(this.binding.declaringClass, this.name, this.value);
81                         this.value.resolveType(scope);
82                         valueType = null; // no need to pursue
83                 } else {
84                         valueType = this.value.resolveType(scope);
85                 }
86                 this.compilerElementPair = new ElementValuePair(this.name, this.value, this.binding);
87                 if (valueType == null)
88                         return;
89
90                 TypeBinding leafType = requiredType.leafComponentType();
91                 if (!((this.value.isConstantValueOfTypeAssignableToType(valueType, requiredType)
92                                 || (requiredType.isBaseType() && BaseTypeBinding.isWidening(requiredType.id, valueType.id)))
93                                 || valueType.isCompatibleWith(requiredType))) {
94
95                         if (!(requiredType.isArrayType() 
96                                         && requiredType.dimensions() == 1 
97                                         && (this.value.isConstantValueOfTypeAssignableToType(valueType, leafType)
98                                                         || (leafType.isBaseType() && BaseTypeBinding.isWidening(leafType.id, valueType.id)))
99                                                         || valueType.isCompatibleWith(leafType))) {
100                                 
101                                 if (leafType.isAnnotationType() && !valueType.isAnnotationType()) {
102                                         scope.problemReporter().annotationValueMustBeAnnotation(this.binding.declaringClass, this.name, this.value, leafType);                          
103                                 } else {
104                                         scope.problemReporter().typeMismatchError(valueType, requiredType, this.value, null);
105                                 }
106                                 return; // may allow to proceed to find more errors at once
107                         }
108                 } else {
109                         scope.compilationUnitScope().recordTypeConversion(requiredType.leafComponentType(), valueType.leafComponentType());
110                         this.value.computeConversion(scope, requiredType, valueType);                           
111                 }
112                 
113                 // annotation methods can only return base types, String, Class, enum type, annotation types and arrays of these
114                 checkAnnotationMethodType: {
115                         switch (leafType.erasure().id) {
116                                 case T_byte :
117                                 case T_short :
118                                 case T_char :
119                                 case T_int :
120                                 case T_long :
121                                 case T_float :
122                                 case T_double :
123                                 case T_boolean :
124                                 case T_JavaLangString :
125                                         if (this.value instanceof ArrayInitializer) {
126                                                 ArrayInitializer initializer = (ArrayInitializer) this.value;
127                                                 final Expression[] expressions = initializer.expressions;
128                                                 if (expressions != null) {
129                                                         for (int i =0, max = expressions.length; i < max; i++) {
130                                                                 Expression expression = expressions[i];
131                                                                 if (expression.resolvedType == null) continue; // fault-tolerance
132                                                                 if (expression.constant == Constant.NotAConstant) {
133                                                                         scope.problemReporter().annotationValueMustBeConstant(this.binding.declaringClass, this.name, expressions[i], false);
134                                                                 }
135                                                         }
136                                                 }
137                                         } else if (this.value.constant == Constant.NotAConstant) {
138                                                 if (valueType.isArrayType()) {
139                                                         scope.problemReporter().annotationValueMustBeArrayInitializer(this.binding.declaringClass, this.name, this.value);
140                                                 } else {
141                                                         scope.problemReporter().annotationValueMustBeConstant(this.binding.declaringClass, this.name, this.value, false);
142                                                 }
143                                         }
144                                         break checkAnnotationMethodType;
145                                 case T_JavaLangClass :
146                                         if (this.value instanceof ArrayInitializer) {
147                                                 ArrayInitializer initializer = (ArrayInitializer) this.value;
148                                                 final Expression[] expressions = initializer.expressions;
149                                                 if (expressions != null) {
150                                                         for (int i =0, max = expressions.length; i < max; i++) {
151                                                                 Expression currentExpression = expressions[i];
152                                                                 if (!(currentExpression instanceof ClassLiteralAccess)) {
153                                                                         scope.problemReporter().annotationValueMustBeClassLiteral(this.binding.declaringClass, this.name, currentExpression);
154                                                                 }
155                                                         }
156                                                 }
157                                         } else if (!(this.value instanceof ClassLiteralAccess)) {
158                                                 scope.problemReporter().annotationValueMustBeClassLiteral(this.binding.declaringClass, this.name, this.value);
159                                         }
160                                         break checkAnnotationMethodType;
161                         }
162                         if (leafType.isEnum()) {
163                                 if (this.value instanceof NullLiteral) {
164                                         scope.problemReporter().annotationValueMustBeConstant(this.binding.declaringClass, this.name, this.value, true);
165                                 } else if (this.value instanceof ArrayInitializer) {
166                                         ArrayInitializer initializer = (ArrayInitializer) this.value;
167                                         final Expression[] expressions = initializer.expressions;
168                                         if (expressions != null) {
169                                                 for (int i =0, max = expressions.length; i < max; i++) {
170                                                         Expression currentExpression = expressions[i];
171                                                         if (currentExpression instanceof NullLiteral) {
172                                                                 scope.problemReporter().annotationValueMustBeConstant(this.binding.declaringClass, this.name, currentExpression, true);
173                                                         } else if (currentExpression instanceof NameReference) {
174                                                                 NameReference nameReference = (NameReference) currentExpression;
175                                                                 final Binding nameReferenceBinding = nameReference.binding;
176                                                                 if (nameReferenceBinding.kind() == Binding.FIELD) {
177                                                                         FieldBinding fieldBinding = (FieldBinding) nameReferenceBinding;
178                                                                         if (!fieldBinding.declaringClass.isEnum()) {
179                                                                                 scope.problemReporter().annotationValueMustBeConstant(this.binding.declaringClass, this.name, currentExpression, true);
180                                                                         }
181                                                                 }
182                                                         }
183                                                 }
184                                         }
185                                 } else if (this.value instanceof NameReference) {
186                                         NameReference nameReference = (NameReference) this.value;
187                                         final Binding nameReferenceBinding = nameReference.binding;
188                                         if (nameReferenceBinding.kind() == Binding.FIELD) {
189                                                 FieldBinding fieldBinding = (FieldBinding) nameReferenceBinding;
190                                                 if (!fieldBinding.declaringClass.isEnum()) {
191                                                         if (!fieldBinding.type.isArrayType()) {
192                                                                 scope.problemReporter().annotationValueMustBeConstant(this.binding.declaringClass, this.name, this.value, true);
193                                                         } else {
194                                                                 scope.problemReporter().annotationValueMustBeArrayInitializer(this.binding.declaringClass, this.name, this.value);
195                                                         }
196                                                 }
197                                         }
198                                 }
199                                 break checkAnnotationMethodType;
200                         }
201                         if (leafType.isAnnotationType()) {
202                                 if (!valueType.leafComponentType().isAnnotationType()) { // check annotation type and also reject null literal
203                                         scope.problemReporter().annotationValueMustBeAnnotation(this.binding.declaringClass, this.name, this.value, leafType);
204                                 } else if (this.value instanceof ArrayInitializer) {
205                                         ArrayInitializer initializer = (ArrayInitializer) this.value;
206                                         final Expression[] expressions = initializer.expressions;
207                                         if (expressions != null) {
208                                                 for (int i =0, max = expressions.length; i < max; i++) {
209                                                         Expression currentExpression = expressions[i];
210                                                         if (currentExpression instanceof NullLiteral || !(currentExpression instanceof Annotation)) {
211                                                                 scope.problemReporter().annotationValueMustBeAnnotation(this.binding.declaringClass, this.name, currentExpression, leafType);
212                                                         }
213                                                 }
214                                         }
215                                 } else if (!(this.value instanceof Annotation)) {
216                                         scope.problemReporter().annotationValueMustBeAnnotation(this.binding.declaringClass, this.name, this.value, leafType);
217                                 }
218                                 break checkAnnotationMethodType;
219                         }
220                 }
221         }
222         
223         public void traverse(ASTVisitor visitor, BlockScope scope) {
224                 if (visitor.visit(this, scope)) {
225                         if (this.value != null) {
226                                 this.value.traverse(visitor, scope);
227                         }
228                 }
229                 visitor.endVisit(this, scope);
230         }
231 }