net.sourceforge.phpeclipse/src/net/sourceforge/phpeclipse/internal/compiler/ast/FieldDeclaration.java

   1 /***********************************************************************************************************************************
   2  * Copyright (c) 2000, 2003 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made
   3  * available under the terms of the Common Public License v1.0 which accompanies this distribution, and is available at
   4  * http://www.eclipse.org/legal/cpl-v10.html
   5  *
   6  * Contributors: IBM Corporation - initial API and implementation
   7  **********************************************************************************************************************************/
   8 package net.sourceforge.phpeclipse.internal.compiler.ast;
   9
  10 import net.sourceforge.phpdt.internal.compiler.ASTVisitor;
  11 import net.sourceforge.phpdt.internal.compiler.flow.FlowContext;
  12 import net.sourceforge.phpdt.internal.compiler.flow.FlowInfo;
  13 import net.sourceforge.phpdt.internal.compiler.impl.Constant;
  14 import net.sourceforge.phpdt.internal.compiler.lookup.ArrayBinding;
  15 import net.sourceforge.phpdt.internal.compiler.lookup.BaseTypeBinding;
  16 import net.sourceforge.phpdt.internal.compiler.lookup.FieldBinding;
  17 import net.sourceforge.phpdt.internal.compiler.lookup.MethodScope;
  18 import net.sourceforge.phpdt.internal.compiler.lookup.Scope;
  19 import net.sourceforge.phpdt.internal.compiler.lookup.SourceTypeBinding;
  20 import net.sourceforge.phpdt.internal.compiler.lookup.TypeBinding;
  21
  22 public class FieldDeclaration extends AbstractVariableDeclaration {
  23   public FieldBinding binding;
  24
  25   boolean hasBeenResolved = false;
  26
  27   //allows to retrieve both the "type" part of the declaration (part1)
  28   //and also the part that decribe the name and the init and optionally
  29   //some other dimension ! ....
  30   //public int[] a, b[] = X, c ;
  31   //for b that would give for
  32   // - part1 : public int[]
  33   // - part2 : b[] = X,
  34
  35   public int endPart1Position;
  36
  37   public int endPart2Position;
  38
  39   public FieldDeclaration() {
  40   }
  41
  42   public FieldDeclaration(char[] name, int sourceStart, int sourceEnd) {
  43
  44     this.name = name;
  45
  46     //due to some declaration like
  47     // int x, y = 3, z , x ;
  48     //the sourceStart and the sourceEnd is ONLY on the name
  49     this.sourceStart = sourceStart;
  50     this.sourceEnd = sourceEnd;
  51   }
  52
  53   public FieldDeclaration(Expression initialization, char[] name, int sourceStart, int sourceEnd) {
  54
  55     this.initialization = initialization;
  56     this.name = name;
  57
  58     //due to some declaration like
  59     // int x, y = 3, z , x ;
  60     //the sourceStart and the sourceEnd is ONLY on the name
  61     this.sourceStart = sourceStart;
  62     this.sourceEnd = sourceEnd;
  63   }
  64
  65   public FlowInfo analyseCode(MethodScope initializationScope, FlowContext flowContext, FlowInfo flowInfo) {
  66
  67     if (this.binding != null && this.binding.isPrivate() && !this.binding.isPrivateUsed()) {
  68       if (!initializationScope.referenceCompilationUnit().compilationResult.hasSyntaxError()) {
  69         initializationScope.problemReporter().unusedPrivateField(this);
  70       }
  71     }
  72     // cannot define static non-constant field inside nested class
  73     if (binding != null && binding.isValidBinding() && binding.isStatic() && binding.constant == NotAConstant
  74         && binding.declaringClass.isNestedType() && binding.declaringClass.isClass() && !binding.declaringClass.isStatic()) {
  75       initializationScope.problemReporter().unexpectedStaticModifierForField((SourceTypeBinding) binding.declaringClass, this);
  76     }
  77
  78     if (initialization != null) {
  79       flowInfo = initialization.analyseCode(initializationScope, flowContext, flowInfo).unconditionalInits();
  80       flowInfo.markAsDefinitelyAssigned(binding);
  81     }
  82     return flowInfo;
  83   }
  84
  85   /**
  86    * Code generation for a field declaration: standard assignment to a field
  87    *
  88    * @param currentScope
  89    *          net.sourceforge.phpdt.internal.compiler.lookup.BlockScope
  90    * @param codeStream
  91    *          net.sourceforge.phpdt.internal.compiler.codegen.CodeStream
  92    */
  93   //    public void generateCode(BlockScope currentScope, CodeStream codeStream) {
  94   //
  95   //            if ((bits & IsReachableMASK) == 0) {
  96   //                    return;
  97   //            }
  98   //            // do not generate initialization code if final and static (constant is then
  99   //            // recorded inside the field itself).
 100   //            int pc = codeStream.position;
 101   //            boolean isStatic;
 102   //            if (initialization != null
 103   //                    && !((isStatic = binding.isStatic()) && binding.constant != NotAConstant)) {
 104   //                    // non-static field, need receiver
 105   //                    if (!isStatic)
 106   //                            codeStream.aload_0();
 107   //                    // generate initialization value
 108   //                    initialization.generateCode(currentScope, codeStream, true);
 109   //                    // store into field
 110   //                    if (isStatic) {
 111   //                            codeStream.putstatic(binding);
 112   //                    } else {
 113   //                            codeStream.putfield(binding);
 114   //                    }
 115   //            }
 116   //            codeStream.recordPositionsFrom(pc, this.sourceStart);
 117   //    }
 118   public TypeBinding getTypeBinding(Scope scope) {
 119
 120     return type.getTypeBinding(scope);
 121   }
 122
 123   public boolean isField() {
 124
 125     return true;
 126   }
 127
 128   public boolean isStatic() {
 129
 130     if (binding != null)
 131       return binding.isStatic();
 132     return (modifiers & AccStatic) != 0;
 133   }
 134
 135   public String name() {
 136
 137     return String.valueOf(name);
 138   }
 139
 140   public void resolve(MethodScope initializationScope) {
 141
 142     // the two <constant = Constant.NotAConstant> could be regrouped into
 143     // a single line but it is clearer to have two lines while the reason of their
 144     // existence is not at all the same. See comment for the second one.
 145
 146     //--------------------------------------------------------
 147     if (!this.hasBeenResolved && binding != null && this.binding.isValidBinding()) {
 148
 149       this.hasBeenResolved = true;
 150
 151       if (isTypeUseDeprecated(this.binding.type, initializationScope))
 152         initializationScope.problemReporter().deprecatedType(this.binding.type, this.type);
 153
 154       this.type.resolvedType = this.binding.type; // update binding for type reference
 155
 156       // the resolution of the initialization hasn't been done
 157       if (this.initialization == null) {
 158         this.binding.constant = Constant.NotAConstant;
 159       } else {
 160         int previous = initializationScope.fieldDeclarationIndex;
 161         try {
 162           initializationScope.fieldDeclarationIndex = this.binding.id;
 163
 164           // break dead-lock cycles by forcing constant to NotAConstant
 165           this.binding.constant = Constant.NotAConstant;
 166
 167           TypeBinding typeBinding = this.binding.type;
 168           TypeBinding initializationTypeBinding;
 169
 170           if (initialization instanceof ArrayInitializer) {
 171
 172             if ((initializationTypeBinding = this.initialization.resolveTypeExpecting(initializationScope, typeBinding)) != null) {
 173               ((ArrayInitializer) this.initialization).binding = (ArrayBinding) initializationTypeBinding;
 174               this.initialization.implicitWidening(typeBinding, initializationTypeBinding);
 175             }
 176           } else if ((initializationTypeBinding = initialization.resolveType(initializationScope)) != null) {
 177
 178             if (this.initialization.isConstantValueOfTypeAssignableToType(initializationTypeBinding, typeBinding)
 179                 || (typeBinding.isBaseType() && BaseTypeBinding.isWidening(typeBinding.id, initializationTypeBinding.id))) {
 180
 181               this.initialization.implicitWidening(typeBinding, initializationTypeBinding);
 182
 183             } else if (initializationTypeBinding.isCompatibleWith(typeBinding)) {
 184               this.initialization.implicitWidening(typeBinding, initializationTypeBinding);
 185
 186             } else {
 187               initializationScope.problemReporter().typeMismatchError(initializationTypeBinding, typeBinding, this);
 188             }
 189             if (this.binding.isFinal()) { // cast from constant actual type to variable type
 190               this.binding.constant = this.initialization.constant.castTo((this.binding.type.id << 4)
 191                   + this.initialization.constant.typeID());
 192             }
 193           } else {
 194             this.binding.constant = NotAConstant;
 195           }
 196         } finally {
 197           initializationScope.fieldDeclarationIndex = previous;
 198           if (this.binding.constant == null)
 199             this.binding.constant = Constant.NotAConstant;
 200         }
 201       }
 202     }
 203   }
 204
 205   public void traverse(ASTVisitor visitor, MethodScope scope) {
 206
 207     if (visitor.visit(this, scope)) {
 208       type.traverse(visitor, scope);
 209       if (initialization != null)
 210         initialization.traverse(visitor, scope);
 211     }
 212     visitor.endVisit(this, scope);
 213   }
 214
 215   /*
 216    * (non-Javadoc)
 217    *
 218    * @see java.lang.Object#equals(java.lang.Object)
 219    */
 220   public boolean equals(Object obj) {
 221     if (obj instanceof FieldDeclaration) {
 222       char[] objName = ((FieldDeclaration) obj).name;
 223       if (name.length != objName.length) {
 224         return false;
 225       }
 226       for (int i = 0; i < objName.length; i++) {
 227         if (name[i] != objName[i]) {
 228           return false;
 229         }
 230       }
 231       return true;
 232     }
 233     return super.equals(obj);
 234   }
 235 }