net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/lookup/SyntheticAccessMethodBinding.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.lookup;
  12
  13 import net.sourceforge.phpdt.internal.compiler.ast.AbstractMethodDeclaration;
  14 import net.sourceforge.phpdt.internal.compiler.ast.FieldDeclaration;
  15 import net.sourceforge.phpdt.internal.compiler.util.CharOperation;
  16
  17 public class SyntheticAccessMethodBinding extends MethodBinding {
  18
  19         public FieldBinding targetReadField;    // read access to a field
  20         public FieldBinding targetWriteField;           // write access to a field
  21         public MethodBinding targetMethod;              // method or constructor
  22
  23         public int accessType;
  24
  25         public final static int FieldReadAccess = 1;
  26         public final static int FieldWriteAccess = 2;
  27         public final static int MethodAccess = 3;
  28         public final static int ConstructorAccess = 4;
  29
  30         final static char[] AccessMethodPrefix = { 'a', 'c', 'c', 'e', 's', 's', '$' };
  31
  32         public int sourceStart = 0; // start position of the matching declaration
  33         public int index; // used for sorting access methods in the class file
  34 public SyntheticAccessMethodBinding(FieldBinding targetField, boolean isReadAccess, ReferenceBinding declaringClass) {
  35         this.modifiers = AccDefault | AccStatic | AccSynthetic;
  36         SourceTypeBinding declaringSourceType = (SourceTypeBinding) declaringClass;
  37         SyntheticAccessMethodBinding[] knownAccessMethods = declaringSourceType.syntheticAccessMethods();
  38         int methodId = knownAccessMethods == null ? 0 : knownAccessMethods.length;
  39         this.index = methodId;
  40         this.selector = CharOperation.concat(AccessMethodPrefix, String.valueOf(methodId).toCharArray());
  41         if (isReadAccess) {
  42                 this.returnType = targetField.type;
  43                 if (targetField.isStatic()) {
  44                         this.parameters = NoParameters;
  45                 } else {
  46                         this.parameters = new TypeBinding[1];
  47                         this.parameters[0] = declaringSourceType;
  48                 }
  49                 this.targetReadField = targetField;
  50                 this.accessType = FieldReadAccess;
  51         } else {
  52                 this.returnType = VoidBinding;
  53                 if (targetField.isStatic()) {
  54                         this.parameters = new TypeBinding[1];
  55                         this.parameters[0] = targetField.type;
  56                 } else {
  57                         this.parameters = new TypeBinding[2];
  58                         this.parameters[0] = declaringSourceType;
  59                         this.parameters[1] = targetField.type;
  60                 }
  61                 this.targetWriteField = targetField;
  62                 this.accessType = FieldWriteAccess;
  63         }
  64         this.thrownExceptions = NoExceptions;
  65         this.declaringClass = declaringSourceType;
  66
  67         // check for method collision
  68         boolean needRename;
  69         do {
  70                 check : {
  71                         needRename = false;
  72                         // check for collision with known methods
  73                         MethodBinding[] methods = declaringSourceType.methods;
  74                         for (int i = 0, length = methods.length; i < length; i++) {
  75                                 if (this.selector == methods[i].selector && this.areParametersEqual(methods[i])) {
  76                                         needRename = true;
  77                                         break check;
  78                                 }
  79                         }
  80                         // check for collision with synthetic accessors
  81                         if (knownAccessMethods != null) {
  82                                 for (int i = 0, length = knownAccessMethods.length; i < length; i++) {
  83                                         if (knownAccessMethods[i] == null) continue;
  84                                         if (this.selector == knownAccessMethods[i].selector && this.areParametersEqual(methods[i])) {
  85                                                 needRename = true;
  86                                                 break check;
  87                                         }
  88                                 }
  89                         }
  90                 }
  91                 if (needRename) { // retry with a selector postfixed by a growing methodId
  92                         this.selector(CharOperation.concat(AccessMethodPrefix, String.valueOf(++methodId).toCharArray()));
  93                 }
  94         } while (needRename);
  95
  96         // retrieve sourceStart position for the target field for line number attributes
  97         FieldDeclaration[] fieldDecls = declaringSourceType.scope.referenceContext.fields;
  98         if (fieldDecls != null) {
  99                 for (int i = 0, max = fieldDecls.length; i < max; i++) {
 100                         if (fieldDecls[i].binding == targetField) {
 101                                 this.sourceStart = fieldDecls[i].sourceStart;
 102                                 return;
 103                         }
 104                 }
 105         }
 106
 107 /* did not find the target field declaration - it is a synthetic one
 108         public class A {
 109                 public class B {
 110                         public class C {
 111                                 void foo() {
 112                                         System.out.println("A.this = " + A.this);
 113                                 }
 114                         }
 115                 }
 116                 public static void main(String args[]) {
 117                         new A().new B().new C().foo();
 118                 }
 119         }
 120 */
 121         // We now at this point - per construction - it is for sure an enclosing instance, we are going to
 122         // show the target field type declaration location.
 123         this.sourceStart = declaringSourceType.scope.referenceContext.sourceStart; // use the target declaring class name position instead
 124 }
 125 public SyntheticAccessMethodBinding(MethodBinding targetMethod, ReferenceBinding receiverType) {
 126
 127         if (targetMethod.isConstructor()) {
 128                 this.initializeConstructorAccessor(targetMethod);
 129         } else {
 130                 this.initializeMethodAccessor(targetMethod, receiverType);
 131         }
 132 }
 133 /**
 134  * An constructor accessor is a constructor with an extra argument (declaringClass), in case of
 135  * collision with an existing constructor, then add again an extra argument (declaringClass again).
 136  */
 137  public void initializeConstructorAccessor(MethodBinding targetConstructor) {
 138
 139         this.targetMethod = targetConstructor;
 140         this.modifiers = AccDefault | AccSynthetic;
 141         SourceTypeBinding sourceType =
 142                 (SourceTypeBinding) targetConstructor.declaringClass;
 143         SyntheticAccessMethodBinding[] knownAccessMethods =
 144                 sourceType.syntheticAccessMethods();
 145         this.index = knownAccessMethods == null ? 0 : knownAccessMethods.length;
 146
 147         this.selector = targetConstructor.selector;
 148         this.returnType = targetConstructor.returnType;
 149         this.accessType = ConstructorAccess;
 150         this.parameters = new TypeBinding[targetConstructor.parameters.length + 1];
 151         System.arraycopy(
 152                 targetConstructor.parameters,
 153                 0,
 154                 this.parameters,
 155                 0,
 156                 targetConstructor.parameters.length);
 157         parameters[targetConstructor.parameters.length] =
 158                 targetConstructor.declaringClass;
 159         this.thrownExceptions = targetConstructor.thrownExceptions;
 160         this.declaringClass = sourceType;
 161
 162         // check for method collision
 163         boolean needRename;
 164         do {
 165                 check : {
 166                         needRename = false;
 167                         // check for collision with known methods
 168                         MethodBinding[] methods = sourceType.methods;
 169                         for (int i = 0, length = methods.length; i < length; i++) {
 170                                 if (this.selector == methods[i].selector
 171                                         && this.areParametersEqual(methods[i])) {
 172                                         needRename = true;
 173                                         break check;
 174                                 }
 175                         }
 176                         // check for collision with synthetic accessors
 177                         if (knownAccessMethods != null) {
 178                                 for (int i = 0, length = knownAccessMethods.length; i < length; i++) {
 179                                         if (knownAccessMethods[i] == null)
 180                                                 continue;
 181                                         if (this.selector == knownAccessMethods[i].selector
 182                                                 && this.areParametersEqual(methods[i])) {
 183                                                 needRename = true;
 184                                                 break check;
 185                                         }
 186                                 }
 187                         }
 188                 }
 189                 if (needRename) { // retry with a new extra argument
 190                         int length = this.parameters.length;
 191                         System.arraycopy(
 192                                 this.parameters,
 193                                 0,
 194                                 this.parameters = new TypeBinding[length + 1],
 195                                 0,
 196                                 length);
 197                         this.parameters[length] = this.declaringClass;
 198                 }
 199         } while (needRename);
 200
 201         // retrieve sourceStart position for the target method for line number attributes
 202         AbstractMethodDeclaration[] methodDecls =
 203                 sourceType.scope.referenceContext.methods;
 204         if (methodDecls != null) {
 205                 for (int i = 0, length = methodDecls.length; i < length; i++) {
 206                         if (methodDecls[i].binding == targetConstructor) {
 207                                 this.sourceStart = methodDecls[i].sourceStart;
 208                                 return;
 209                         }
 210                 }
 211         }
 212 }
 213 /**
 214  * An method accessor is a method with an access$N selector, where N is incremented in case of collisions.
 215  */
 216
 217 public void initializeMethodAccessor(MethodBinding targetMethod, ReferenceBinding declaringClass) {
 218
 219         this.targetMethod = targetMethod;
 220         this.modifiers = AccDefault | AccStatic | AccSynthetic;
 221         SourceTypeBinding declaringSourceType = (SourceTypeBinding) declaringClass;
 222         SyntheticAccessMethodBinding[] knownAccessMethods = declaringSourceType.syntheticAccessMethods();
 223         int methodId = knownAccessMethods == null ? 0 : knownAccessMethods.length;
 224         this.index = methodId;
 225
 226         this.selector = CharOperation.concat(AccessMethodPrefix, String.valueOf(methodId).toCharArray());
 227         this.returnType = targetMethod.returnType;
 228         this.accessType = MethodAccess;
 229
 230         if (targetMethod.isStatic()) {
 231                 this.parameters = targetMethod.parameters;
 232         } else {
 233                 this.parameters = new TypeBinding[targetMethod.parameters.length + 1];
 234                 this.parameters[0] = declaringSourceType;
 235                 System.arraycopy(targetMethod.parameters, 0, this.parameters, 1, targetMethod.parameters.length);
 236         }
 237         this.thrownExceptions = targetMethod.thrownExceptions;
 238         this.declaringClass = declaringSourceType;
 239
 240         // check for method collision
 241         boolean needRename;
 242         do {
 243                 check : {
 244                         needRename = false;
 245                         // check for collision with known methods
 246                         MethodBinding[] methods = declaringSourceType.methods;
 247                         for (int i = 0, length = methods.length; i < length; i++) {
 248                                 if (this.selector == methods[i].selector && this.areParametersEqual(methods[i])) {
 249                                         needRename = true;
 250                                         break check;
 251                                 }
 252                         }
 253                         // check for collision with synthetic accessors
 254                         if (knownAccessMethods != null) {
 255                                 for (int i = 0, length = knownAccessMethods.length; i < length; i++) {
 256                                         if (knownAccessMethods[i] == null) continue;
 257                                         if (this.selector == knownAccessMethods[i].selector && this.areParametersEqual(methods[i])) {
 258                                                 needRename = true;
 259                                                 break check;
 260                                         }
 261                                 }
 262                         }
 263                 }
 264                 if (needRename) { // retry with a selector & a growing methodId
 265                         this.selector(CharOperation.concat(AccessMethodPrefix, String.valueOf(++methodId).toCharArray()));
 266                 }
 267         } while (needRename);
 268
 269         // retrieve sourceStart position for the target method for line number attributes
 270         AbstractMethodDeclaration[] methodDecls = declaringSourceType.scope.referenceContext.methods;
 271         if (methodDecls != null) {
 272                 for (int i = 0, length = methodDecls.length; i < length; i++) {
 273                         if (methodDecls[i].binding == targetMethod) {
 274                                 this.sourceStart = methodDecls[i].sourceStart;
 275                                 return;
 276                         }
 277                 }
 278         }
 279 }
 280 protected boolean isConstructorRelated() {
 281         return accessType == ConstructorAccess;
 282 }
 283 }