1) Fixed calculation of the new indentation method of splitted strings.
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / compiler / ast / MessageSend.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.lookup.BindingIds;
17 import net.sourceforge.phpdt.internal.compiler.lookup.BlockScope;
18 import net.sourceforge.phpdt.internal.compiler.lookup.InvocationSite;
19 import net.sourceforge.phpdt.internal.compiler.lookup.MethodBinding;
20 import net.sourceforge.phpdt.internal.compiler.lookup.ProblemMethodBinding;
21 import net.sourceforge.phpdt.internal.compiler.lookup.ReferenceBinding;
22 import net.sourceforge.phpdt.internal.compiler.lookup.SourceTypeBinding;
23 import net.sourceforge.phpdt.internal.compiler.lookup.TypeBinding;
24
25 public class MessageSend extends Expression implements InvocationSite {
26         public Expression receiver;
27
28         public char[] selector;
29
30         public Expression[] arguments;
31
32         public MethodBinding binding, codegenBinding;
33
34         public long nameSourcePosition; // (start<<32)+end
35
36         MethodBinding syntheticAccessor;
37
38         public TypeBinding receiverType, qualifyingType;
39
40         public MessageSend() {
41
42         }
43
44         public FlowInfo analyseCode(BlockScope currentScope,
45                         FlowContext flowContext, FlowInfo flowInfo) {
46
47                 flowInfo = receiver.analyseCode(currentScope, flowContext, flowInfo,
48                                 !binding.isStatic()).unconditionalInits();
49                 if (arguments != null) {
50                         int length = arguments.length;
51                         for (int i = 0; i < length; i++) {
52                                 flowInfo = arguments[i].analyseCode(currentScope, flowContext,
53                                                 flowInfo).unconditionalInits();
54                         }
55                 }
56                 ReferenceBinding[] thrownExceptions;
57                 if ((thrownExceptions = binding.thrownExceptions) != NoExceptions) {
58                         // must verify that exceptions potentially thrown by this expression
59                         // are caught in the method
60                         flowContext.checkExceptionHandlers(thrownExceptions, this,
61                                         flowInfo, currentScope);
62                 }
63                 manageSyntheticAccessIfNecessary(currentScope);
64                 return flowInfo;
65         }
66
67         /**
68          * MessageSend code generation
69          * 
70          * @param currentScope
71          *            net.sourceforge.phpdt.internal.compiler.lookup.BlockScope
72          * @param codeStream
73          *            net.sourceforge.phpdt.internal.compiler.codegen.CodeStream
74          * @param valueRequired
75          *            boolean
76          */
77         // public void generateCode(BlockScope currentScope, CodeStream codeStream,
78         // boolean valueRequired) {
79         //
80         // int pc = codeStream.position;
81         //
82         // // generate receiver/enclosing instance access
83         // boolean isStatic = codegenBinding.isStatic();
84         // // outer access ?
85         // if (!isStatic && ((bits & DepthMASK) != 0) && receiver.isImplicitThis()){
86         // // outer method can be reached through emulation if implicit access
87         // ReferenceBinding targetType =
88         // currentScope.enclosingSourceType().enclosingTypeAt((bits & DepthMASK) >>
89         // DepthSHIFT);
90         // Object[] path = currentScope.getEmulationPath(targetType, true /*only
91         // exact match*/, false/*consider enclosing arg*/);
92         // codeStream.generateOuterAccess(path, this, targetType, currentScope);
93         // } else {
94         // receiver.generateCode(currentScope, codeStream, !isStatic);
95         // }
96         // // generate arguments
97         // if (arguments != null){
98         // for (int i = 0, max = arguments.length; i < max; i++){
99         // arguments[i].generateCode(currentScope, codeStream, true);
100         // }
101         // }
102         // // actual message invocation
103         // if (syntheticAccessor == null){
104         // if (isStatic){
105         // codeStream.invokestatic(codegenBinding);
106         // } else {
107         // if( (receiver.isSuper()) || codegenBinding.isPrivate()){
108         // codeStream.invokespecial(codegenBinding);
109         // } else {
110         // if (codegenBinding.declaringClass.isInterface()){
111         // codeStream.invokeinterface(codegenBinding);
112         // } else {
113         // codeStream.invokevirtual(codegenBinding);
114         // }
115         // }
116         // }
117         // } else {
118         // codeStream.invokestatic(syntheticAccessor);
119         // }
120         // // operation on the returned value
121         // if (valueRequired){
122         // // implicit conversion if necessary
123         // codeStream.generateImplicitConversion(implicitConversion);
124         // } else {
125         // // pop return value if any
126         // switch(binding.returnType.id){
127         // case T_long :
128         // case T_double :
129         // codeStream.pop2();
130         // break;
131         // case T_void :
132         // break;
133         // default:
134         // codeStream.pop();
135         // }
136         // }
137         // codeStream.recordPositionsFrom(pc, (int)(this.nameSourcePosition >>>
138         // 32)); // highlight selector
139         // }
140         public boolean isSuperAccess() {
141                 return receiver.isSuper();
142         }
143
144         public boolean isTypeAccess() {
145                 return receiver != null && receiver.isTypeReference();
146         }
147
148         public void manageSyntheticAccessIfNecessary(BlockScope currentScope) {
149
150                 if (binding.isPrivate()) {
151
152                         // depth is set for both implicit and explicit access (see
153                         // MethodBinding#canBeSeenBy)
154                         if (currentScope.enclosingSourceType() != binding.declaringClass) {
155
156                                 syntheticAccessor = ((SourceTypeBinding) binding.declaringClass)
157                                                 .addSyntheticMethod(binding, isSuperAccess());
158                                 currentScope.problemReporter().needToEmulateMethodAccess(
159                                                 binding, this);
160                                 return;
161                         }
162
163                 } else if (receiver instanceof QualifiedSuperReference) { // qualified
164                                                                                                                                         // super
165
166                         // qualified super need emulation always
167                         SourceTypeBinding destinationType = (SourceTypeBinding) (((QualifiedSuperReference) receiver).currentCompatibleType);
168                         syntheticAccessor = destinationType.addSyntheticMethod(binding,
169                                         isSuperAccess());
170                         currentScope.problemReporter().needToEmulateMethodAccess(binding,
171                                         this);
172                         return;
173
174                 } else if (binding.isProtected()) {
175
176                         SourceTypeBinding enclosingSourceType;
177                         if (((bits & DepthMASK) != 0)
178                                         && binding.declaringClass.getPackage() != (enclosingSourceType = currentScope
179                                                         .enclosingSourceType()).getPackage()) {
180
181                                 SourceTypeBinding currentCompatibleType = (SourceTypeBinding) enclosingSourceType
182                                                 .enclosingTypeAt((bits & DepthMASK) >> DepthSHIFT);
183                                 syntheticAccessor = currentCompatibleType.addSyntheticMethod(
184                                                 binding, isSuperAccess());
185                                 currentScope.problemReporter().needToEmulateMethodAccess(
186                                                 binding, this);
187                                 return;
188                         }
189                 }
190                 // if the binding declaring class is not visible, need special action
191                 // for runtime compatibility on 1.2 VMs : change the declaring class of
192                 // the binding
193                 // NOTE: from target 1.2 on, method's declaring class is touched if any
194                 // different from receiver type
195                 // and not from Object or implicit static method call.
196                 // if (binding.declaringClass != this.qualifyingType
197                 // && !this.qualifyingType.isArrayType()
198                 // && ((currentScope.environment().options.targetJDK >=
199                 // CompilerOptions.JDK1_2
200                 // && (!receiver.isImplicitThis() || !binding.isStatic())
201                 // && binding.declaringClass.id != T_Object) // no change for Object
202                 // methods
203                 // || !binding.declaringClass.canBeSeenBy(currentScope))) {
204                 //
205                 // this.codegenBinding =
206                 // currentScope.enclosingSourceType().getUpdatedMethodBinding(binding,
207                 // (ReferenceBinding) this.qualifyingType);
208                 // }
209         }
210
211         public StringBuffer printExpression(int indent, StringBuffer output) {
212
213                 if (!receiver.isImplicitThis())
214                         receiver.printExpression(0, output).append('.');
215                 output.append(selector).append('('); //$NON-NLS-1$
216                 if (arguments != null) {
217                         for (int i = 0; i < arguments.length; i++) {
218                                 if (i > 0)
219                                         output.append(", "); //$NON-NLS-1$
220                                 arguments[i].printExpression(0, output);
221                         }
222                 }
223                 return output.append(')');
224         }
225
226         public TypeBinding resolveType(BlockScope scope) {
227                 // Answer the signature return type
228                 // Base type promotion
229
230                 constant = NotAConstant;
231                 this.qualifyingType = this.receiverType = receiver.resolveType(scope);
232
233                 // will check for null after args are resolved
234                 TypeBinding[] argumentTypes = NoParameters;
235                 if (arguments != null) {
236                         boolean argHasError = false; // typeChecks all arguments
237                         int length = arguments.length;
238                         argumentTypes = new TypeBinding[length];
239                         for (int i = 0; i < length; i++) {
240                                 if ((argumentTypes[i] = arguments[i].resolveType(scope)) == null) {
241                                         argHasError = true;
242                                 }
243                         }
244                         if (argHasError) {
245                                 if (receiverType instanceof ReferenceBinding) {
246                                         // record any selector match, for clients who may still need
247                                         // hint about possible method match
248                                         this.codegenBinding = this.binding = scope.findMethod(
249                                                         (ReferenceBinding) receiverType, selector,
250                                                         new TypeBinding[] {}, this);
251                                 }
252                                 return null;
253                         }
254                 }
255                 if (this.receiverType == null)
256                         return null;
257
258                 // base type cannot receive any message
259                 if (this.receiverType.isBaseType()) {
260                         scope.problemReporter().errorNoMethodFor(this, this.receiverType,
261                                         argumentTypes);
262                         return null;
263                 }
264
265                 this.codegenBinding = this.binding = receiver.isImplicitThis() ? scope
266                                 .getImplicitMethod(selector, argumentTypes, this) : scope
267                                 .getMethod(this.receiverType, selector, argumentTypes, this);
268                 if (!binding.isValidBinding()) {
269                         if (binding.declaringClass == null) {
270                                 if (this.receiverType instanceof ReferenceBinding) {
271                                         binding.declaringClass = (ReferenceBinding) this.receiverType;
272                                 } else {
273                                         scope.problemReporter().errorNoMethodFor(this,
274                                                         this.receiverType, argumentTypes);
275                                         return null;
276                                 }
277                         }
278                         scope.problemReporter().invalidMethod(this, binding);
279                         // record the closest match, for clients who may still need hint
280                         // about possible method match
281                         if (binding instanceof ProblemMethodBinding) {
282                                 MethodBinding closestMatch = ((ProblemMethodBinding) binding).closestMatch;
283                                 if (closestMatch != null)
284                                         this.codegenBinding = this.binding = closestMatch;
285                         }
286                         return binding == null ? null : binding.returnType;
287                 }
288                 if (!binding.isStatic()) {
289                         // the "receiver" must not be a type, in other words, a
290                         // NameReference that the TC has bound to a Type
291                         if (receiver instanceof NameReference
292                                         && (((NameReference) receiver).bits & BindingIds.TYPE) != 0) {
293                                 scope.problemReporter().mustUseAStaticMethod(this, binding);
294                         }
295                 } else {
296                         // static message invoked through receiver? legal but unoptimal
297                         // (optional warning).
298                         if (!(receiver.isImplicitThis() || receiver.isSuper() || (receiver instanceof NameReference && (((NameReference) receiver).bits & BindingIds.TYPE) != 0))) {
299                                 scope.problemReporter().unnecessaryReceiverForStaticMethod(
300                                                 this, binding);
301                         }
302                 }
303                 if (arguments != null)
304                         for (int i = 0; i < arguments.length; i++)
305                                 arguments[i].implicitWidening(binding.parameters[i],
306                                                 argumentTypes[i]);
307
308                 // -------message send that are known to fail at compile time-----------
309                 if (binding.isAbstract()) {
310                         if (receiver.isSuper()) {
311                                 scope.problemReporter().cannotDireclyInvokeAbstractMethod(this,
312                                                 binding);
313                         }
314                         // abstract private methods cannot occur nor abstract
315                         // static............
316                 }
317                 if (isMethodUseDeprecated(binding, scope))
318                         scope.problemReporter().deprecatedMethod(binding, this);
319
320                 return this.resolvedType = binding.returnType;
321         }
322
323         public void setActualReceiverType(ReferenceBinding receiverType) {
324                 this.qualifyingType = receiverType;
325         }
326
327         public void setDepth(int depth) {
328                 bits &= ~DepthMASK; // flush previous depth if any
329                 if (depth > 0) {
330                         bits |= (depth & 0xFF) << DepthSHIFT; // encoded on 8 bits
331                 }
332         }
333
334         public void setFieldIndex(int depth) {
335                 // ignore for here
336         }
337
338         public String toStringExpression() {
339
340                 String s = ""; //$NON-NLS-1$
341                 if (!receiver.isImplicitThis())
342                         s = s + receiver.toStringExpression() + "."; //$NON-NLS-1$
343                 s = s + new String(selector) + "("; //$NON-NLS-1$
344                 if (arguments != null)
345                         for (int i = 0; i < arguments.length; i++) {
346                                 s = s + arguments[i].toStringExpression();
347                                 if (i != arguments.length - 1)
348                                         s = s + " , ";};; //$NON-NLS-1$
349                 s = s + ")"; //$NON-NLS-1$
350                 return s;
351         }
352
353         public void traverse(ASTVisitor visitor, BlockScope blockScope) {
354                 if (visitor.visit(this, blockScope)) {
355                         receiver.traverse(visitor, blockScope);
356                         if (arguments != null) {
357                                 int argumentsLength = arguments.length;
358                                 for (int i = 0; i < argumentsLength; i++)
359                                         arguments[i].traverse(visitor, blockScope);
360                         }
361                 }
362                 visitor.endVisit(this, blockScope);
363         }
364 }