Ignore case for functions in the PHP hover
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpeclipse / internal / compiler / ast / AllocationExpression.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.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.lookup.BlockScope;
17 import net.sourceforge.phpdt.internal.compiler.lookup.InvocationSite;
18 import net.sourceforge.phpdt.internal.compiler.lookup.LocalTypeBinding;
19 import net.sourceforge.phpdt.internal.compiler.lookup.LocalVariableBinding;
20 import net.sourceforge.phpdt.internal.compiler.lookup.MethodBinding;
21 import net.sourceforge.phpdt.internal.compiler.lookup.NestedTypeBinding;
22 import net.sourceforge.phpdt.internal.compiler.lookup.ReferenceBinding;
23 import net.sourceforge.phpdt.internal.compiler.lookup.SourceTypeBinding;
24 import net.sourceforge.phpdt.internal.compiler.lookup.SyntheticArgumentBinding;
25 import net.sourceforge.phpdt.internal.compiler.lookup.TypeBinding;
26
27 public class AllocationExpression
28         extends Expression
29         implements InvocationSite {
30                 
31         public TypeReference type;
32         public Expression[] arguments;
33         public MethodBinding binding;
34
35         MethodBinding syntheticAccessor;
36
37         public AllocationExpression() {
38         }
39
40         public FlowInfo analyseCode(
41                 BlockScope currentScope,
42                 FlowContext flowContext,
43                 FlowInfo flowInfo) {
44
45                 // check captured variables are initialized in current context (26134)
46                 checkCapturedLocalInitializationIfNecessary(this.binding.declaringClass, currentScope, flowInfo);
47
48                 // process arguments
49                 if (arguments != null) {
50                         for (int i = 0, count = arguments.length; i < count; i++) {
51                                 flowInfo =
52                                         arguments[i]
53                                                 .analyseCode(currentScope, flowContext, flowInfo)
54                                                 .unconditionalInits();
55                         }
56                 }
57                 // record some dependency information for exception types
58                 ReferenceBinding[] thrownExceptions;
59                 if (((thrownExceptions = this.binding.thrownExceptions).length) != 0) {
60                         // check exception handling
61                         flowContext.checkExceptionHandlers(
62                                 thrownExceptions,
63                                 this,
64                                 flowInfo,
65                                 currentScope);
66                 }
67                 manageEnclosingInstanceAccessIfNecessary(currentScope);
68                 manageSyntheticAccessIfNecessary(currentScope);
69                 
70                 return flowInfo;
71         }
72
73         public void checkCapturedLocalInitializationIfNecessary(ReferenceBinding checkedType, BlockScope currentScope, FlowInfo flowInfo) {
74
75                 if (checkedType.isLocalType() 
76                                 && !checkedType.isAnonymousType()
77                                 && !currentScope.isDefinedInType(checkedType)) { // only check external allocations
78                         NestedTypeBinding nestedType = (NestedTypeBinding) checkedType;
79                         SyntheticArgumentBinding[] syntheticArguments = nestedType.syntheticOuterLocalVariables();
80                         if (syntheticArguments != null) 
81                                 for (int i = 0, count = syntheticArguments.length; i < count; i++){
82                                         SyntheticArgumentBinding syntheticArgument = syntheticArguments[i];
83                                         LocalVariableBinding targetLocal;
84                                         if ((targetLocal = syntheticArgument.actualOuterLocalVariable) == null) continue;
85 //                                      if (targetLocal.declaration != null && !flowInfo.isDefinitelyAssigned(targetLocal)){
86 //                                              currentScope.problemReporter().uninitializedLocalVariable(targetLocal, this);
87 //                                      }
88                                 }
89                                                 
90                 }
91         }
92         
93         public Expression enclosingInstance() {
94                 return null;
95         }
96
97 //      public void generateCode(
98 //              BlockScope currentScope,
99 //              CodeStream codeStream,
100 //              boolean valueRequired) {
101 //
102 //              int pc = codeStream.position;
103 //              ReferenceBinding allocatedType = binding.declaringClass;
104 //
105 //              codeStream.new_(allocatedType);
106 //              if (valueRequired) {
107 //                      codeStream.dup();
108 //              }
109 //              // better highlight for allocation: display the type individually
110 //              codeStream.recordPositionsFrom(pc, type.sourceStart);
111 //
112 //              // handling innerclass instance allocation - enclosing instance arguments
113 //              if (allocatedType.isNestedType()) {
114 //                      codeStream.generateSyntheticEnclosingInstanceValues(
115 //                              currentScope,
116 //                              allocatedType,
117 //                              enclosingInstance(),
118 //                              this);
119 //              }
120 //              // generate the arguments for constructor
121 //              if (arguments != null) {
122 //                      for (int i = 0, count = arguments.length; i < count; i++) {
123 //                              arguments[i].generateCode(currentScope, codeStream, true);
124 //                      }
125 //              }
126 //              // handling innerclass instance allocation - outer local arguments
127 //              if (allocatedType.isNestedType()) {
128 //                      codeStream.generateSyntheticOuterArgumentValues(
129 //                              currentScope,
130 //                              allocatedType,
131 //                              this);
132 //              }
133 //              // invoke constructor
134 //              if (syntheticAccessor == null) {
135 //                      codeStream.invokespecial(binding);
136 //              } else {
137 //                      // synthetic accessor got some extra arguments appended to its signature, which need values
138 //                      for (int i = 0,
139 //                              max = syntheticAccessor.parameters.length - binding.parameters.length;
140 //                              i < max;
141 //                              i++) {
142 //                              codeStream.aconst_null();
143 //                      }
144 //                      codeStream.invokespecial(syntheticAccessor);
145 //              }
146 //              codeStream.recordPositionsFrom(pc, this.sourceStart);
147 //      }
148
149         public boolean isSuperAccess() {
150
151                 return false;
152         }
153
154         public boolean isTypeAccess() {
155
156                 return true;
157         }
158
159         /* Inner emulation consists in either recording a dependency 
160          * link only, or performing one level of propagation.
161          *
162          * Dependency mechanism is used whenever dealing with source target
163          * types, since by the time we reach them, we might not yet know their
164          * exact need.
165          */
166         public void manageEnclosingInstanceAccessIfNecessary(BlockScope currentScope) {
167
168                 ReferenceBinding allocatedType;
169
170                 // perform some emulation work in case there is some and we are inside a local type only
171                 if ((allocatedType = binding.declaringClass).isNestedType()
172                         && currentScope.enclosingSourceType().isLocalType()) {
173
174                         if (allocatedType.isLocalType()) {
175                                 ((LocalTypeBinding) allocatedType).addInnerEmulationDependent(currentScope, false);
176                                 // request cascade of accesses
177                         } else {
178                                 // locally propagate, since we already now the desired shape for sure
179                                 currentScope.propagateInnerEmulation(allocatedType, false);
180                                 // request cascade of accesses
181                         }
182                 }
183         }
184
185         public void manageSyntheticAccessIfNecessary(BlockScope currentScope) {
186
187                 if (binding.isPrivate()
188                         && (currentScope.enclosingSourceType() != binding.declaringClass)) {
189
190 //                      if (currentScope
191 //                              .environment()
192 //                              .options
193 //                              .isPrivateConstructorAccessChangingVisibility) {
194 //                              binding.tagForClearingPrivateModifier();
195 //                              // constructor will not be dumped as private, no emulation required thus
196 //                      } else {
197                                 syntheticAccessor =
198                                         ((SourceTypeBinding) binding.declaringClass).addSyntheticMethod(binding, isSuperAccess());
199                                 currentScope.problemReporter().needToEmulateMethodAccess(binding, this);
200 //                      }
201                 }
202         }
203         public StringBuffer printExpression(int indent, StringBuffer output) {
204
205                 output.append("new "); //$NON-NLS-1$
206                 type.printExpression(0, output); 
207                 output.append('(');
208                 if (arguments != null) {
209                         for (int i = 0; i < arguments.length; i++) {
210                                 if (i > 0) output.append(", "); //$NON-NLS-1$
211                                 arguments[i].printExpression(0, output);
212                         }
213                 }
214                 return output.append(')');
215         }
216         public TypeBinding resolveType(BlockScope scope) {
217
218                 // Propagate the type checking to the arguments, and check if the constructor is defined.
219                 constant = NotAConstant;
220                 this.resolvedType = type.resolveType(scope);
221                 // will check for null after args are resolved
222
223                 // buffering the arguments' types
224                 TypeBinding[] argumentTypes = NoParameters;
225                 if (arguments != null) {
226                         boolean argHasError = false;
227                         int length = arguments.length;
228                         argumentTypes = new TypeBinding[length];
229                         for (int i = 0; i < length; i++)
230                                 if ((argumentTypes[i] = arguments[i].resolveType(scope)) == null)
231                                         argHasError = true;
232                         if (argHasError)
233                                 return this.resolvedType;
234                 }
235                 if (this.resolvedType == null)
236                         return null;
237
238                 if (!this.resolvedType.canBeInstantiated()) {
239                         scope.problemReporter().cannotInstantiate(type, this.resolvedType);
240                         return this.resolvedType;
241                 }
242                 ReferenceBinding allocatedType = (ReferenceBinding) this.resolvedType;
243                 if (!(binding = scope.getConstructor(allocatedType, argumentTypes, this))
244                         .isValidBinding()) {
245                         if (binding.declaringClass == null)
246                                 binding.declaringClass = allocatedType;
247                         scope.problemReporter().invalidConstructor(this, binding);
248                         return this.resolvedType;
249                 }
250                 if (isMethodUseDeprecated(binding, scope))
251                         scope.problemReporter().deprecatedMethod(binding, this);
252
253                 if (arguments != null)
254                         for (int i = 0; i < arguments.length; i++)
255                                 arguments[i].implicitWidening(binding.parameters[i], argumentTypes[i]);
256                 return allocatedType;
257         }
258
259         public void setActualReceiverType(ReferenceBinding receiverType) {
260                 // ignored
261         }
262
263         public void setDepth(int i) {
264                 // ignored
265         }
266
267         public void setFieldIndex(int i) {
268                 // ignored
269         }
270
271         public String toStringExpression() {
272
273                 String s = "new " + type.toString(0); //$NON-NLS-1$
274                 if (arguments == null)
275                         s = s + "()"; //$NON-NLS-1$
276                 else {
277                         s = s + "("; //$NON-NLS-1$
278                         for (int i = 0; i < arguments.length; i++) {
279                                 s = s + arguments[i].toStringExpression();
280                                 if (i == (arguments.length - 1))
281                                         s = s + ")"; //$NON-NLS-1$
282                                 else
283                                         s = s + ", "; //$NON-NLS-1$
284                         }
285                 }
286                 return s;
287         }
288
289         public void traverse(ASTVisitor visitor, BlockScope scope) {
290
291                 if (visitor.visit(this, scope)) {
292                         int argumentsLength;
293                         type.traverse(visitor, scope);
294                         if (arguments != null) {
295                                 argumentsLength = arguments.length;
296                                 for (int i = 0; i < argumentsLength; i++)
297                                         arguments[i].traverse(visitor, scope);
298                         }
299                 }
300                 visitor.endVisit(this, scope);
301         }
302 }