net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/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.phpdt.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,
  54                         int sourceStart, int sourceEnd) {
  55
  56                 this.initialization = initialization;
  57                 this.name = name;
  58
  59                 // due to some declaration like
  60                 // int x, y = 3, z , x ;
  61                 // the sourceStart and the sourceEnd is ONLY on the name
  62                 this.sourceStart = sourceStart;
  63                 this.sourceEnd = sourceEnd;
  64         }
  65
  66         public FlowInfo analyseCode(MethodScope initializationScope,
  67                         FlowContext flowContext, FlowInfo flowInfo) {
  68
  69                 if (this.binding != null && this.binding.isPrivate()
  70                                 && !this.binding.isPrivateUsed()) {
  71                         if (!initializationScope.referenceCompilationUnit().compilationResult
  72                                         .hasSyntaxError()) {
  73                                 initializationScope.problemReporter().unusedPrivateField(this);
  74                         }
  75                 }
  76                 // cannot define static non-constant field inside nested class
  77                 if (binding != null && binding.isValidBinding() && binding.isStatic()
  78                                 && binding.constant == NotAConstant
  79                                 && binding.declaringClass.isNestedType()
  80                                 && binding.declaringClass.isClass()
  81                                 && !binding.declaringClass.isStatic()) {
  82                         initializationScope.problemReporter()
  83                                         .unexpectedStaticModifierForField(
  84                                                         (SourceTypeBinding) binding.declaringClass, this);
  85                 }
  86
  87                 if (initialization != null) {
  88                         flowInfo = initialization.analyseCode(initializationScope,
  89                                         flowContext, flowInfo).unconditionalInits();
  90                         flowInfo.markAsDefinitelyAssigned(binding);
  91                 }
  92                 return flowInfo;
  93         }
  94
  95         /**
  96          * Code generation for a field declaration: standard assignment to a field
  97          *
  98          * @param currentScope
  99          *            net.sourceforge.phpdt.internal.compiler.lookup.BlockScope
 100          * @param codeStream
 101          *            net.sourceforge.phpdt.internal.compiler.codegen.CodeStream
 102          */
 103         // public void generateCode(BlockScope currentScope, CodeStream codeStream)
 104         // {
 105         //
 106         // if ((bits & IsReachableMASK) == 0) {
 107         // return;
 108         // }
 109         // // do not generate initialization code if final and static (constant is
 110         // then
 111         // // recorded inside the field itself).
 112         // int pc = codeStream.position;
 113         // boolean isStatic;
 114         // if (initialization != null
 115         // && !((isStatic = binding.isStatic()) && binding.constant !=
 116         // NotAConstant)) {
 117         // // non-static field, need receiver
 118         // if (!isStatic)
 119         // codeStream.aload_0();
 120         // // generate initialization value
 121         // initialization.generateCode(currentScope, codeStream, true);
 122         // // store into field
 123         // if (isStatic) {
 124         // codeStream.putstatic(binding);
 125         // } else {
 126         // codeStream.putfield(binding);
 127         // }
 128         // }
 129         // codeStream.recordPositionsFrom(pc, this.sourceStart);
 130         // }
 131         public TypeBinding getTypeBinding(Scope scope) {
 132
 133                 return type.getTypeBinding(scope);
 134         }
 135
 136         public boolean isField() {
 137
 138                 return true;
 139         }
 140
 141         public boolean isStatic() {
 142
 143                 if (binding != null)
 144                         return binding.isStatic();
 145                 return (modifiers & AccStatic) != 0;
 146         }
 147
 148         public String name() {
 149
 150                 return String.valueOf(name);
 151         }
 152
 153         public void resolve(MethodScope initializationScope) {
 154
 155                 // the two <constant = Constant.NotAConstant> could be regrouped into
 156                 // a single line but it is clearer to have two lines while the reason of
 157                 // their
 158                 // existence is not at all the same. See comment for the second one.
 159
 160                 // --------------------------------------------------------
 161                 if (!this.hasBeenResolved && binding != null
 162                                 && this.binding.isValidBinding()) {
 163
 164                         this.hasBeenResolved = true;
 165
 166                         if (isTypeUseDeprecated(this.binding.type, initializationScope))
 167                                 initializationScope.problemReporter().deprecatedType(
 168                                                 this.binding.type, this.type);
 169
 170                         this.type.resolvedType = this.binding.type; // update binding for
 171                                                                                                                 // type reference
 172
 173                         // the resolution of the initialization hasn't been done
 174                         if (this.initialization == null) {
 175                                 this.binding.constant = Constant.NotAConstant;
 176                         } else {
 177                                 int previous = initializationScope.fieldDeclarationIndex;
 178                                 try {
 179                                         initializationScope.fieldDeclarationIndex = this.binding.id;
 180
 181                                         // break dead-lock cycles by forcing constant to
 182                                         // NotAConstant
 183                                         this.binding.constant = Constant.NotAConstant;
 184
 185                                         TypeBinding typeBinding = this.binding.type;
 186                                         TypeBinding initializationTypeBinding;
 187
 188                                         if (initialization instanceof ArrayInitializer) {
 189
 190                                                 if ((initializationTypeBinding = this.initialization
 191                                                                 .resolveTypeExpecting(initializationScope,
 192                                                                                 typeBinding)) != null) {
 193                                                         ((ArrayInitializer) this.initialization).binding = (ArrayBinding) initializationTypeBinding;
 194                                                         this.initialization.implicitWidening(typeBinding,
 195                                                                         initializationTypeBinding);
 196                                                 }
 197                                         } else if ((initializationTypeBinding = initialization
 198                                                         .resolveType(initializationScope)) != null) {
 199
 200                                                 if (this.initialization
 201                                                                 .isConstantValueOfTypeAssignableToType(
 202                                                                                 initializationTypeBinding, typeBinding)
 203                                                                 || (typeBinding.isBaseType() && BaseTypeBinding
 204                                                                                 .isWidening(typeBinding.id,
 205                                                                                                 initializationTypeBinding.id))) {
 206
 207                                                         this.initialization.implicitWidening(typeBinding,
 208                                                                         initializationTypeBinding);
 209
 210                                                 } else if (initializationTypeBinding
 211                                                                 .isCompatibleWith(typeBinding)) {
 212                                                         this.initialization.implicitWidening(typeBinding,
 213                                                                         initializationTypeBinding);
 214
 215                                                 } else {
 216                                                         initializationScope.problemReporter()
 217                                                                         .typeMismatchError(
 218                                                                                         initializationTypeBinding,
 219                                                                                         typeBinding, this);
 220                                                 }
 221                                                 if (this.binding.isFinal()) { // cast from constant
 222                                                                                                                 // actual type to
 223                                                                                                                 // variable type
 224                                                         this.binding.constant = this.initialization.constant
 225                                                                         .castTo((this.binding.type.id << 4)
 226                                                                                         + this.initialization.constant
 227                                                                                                         .typeID());
 228                                                 }
 229                                         } else {
 230                                                 this.binding.constant = NotAConstant;
 231                                         }
 232                                 } finally {
 233                                         initializationScope.fieldDeclarationIndex = previous;
 234                                         if (this.binding.constant == null)
 235                                                 this.binding.constant = Constant.NotAConstant;
 236                                 }
 237                         }
 238                 }
 239         }
 240
 241         public void traverse(ASTVisitor visitor, MethodScope scope) {
 242
 243                 if (visitor.visit(this, scope)) {
 244                         type.traverse(visitor, scope);
 245                         if (initialization != null)
 246                                 initialization.traverse(visitor, scope);
 247                 }
 248                 visitor.endVisit(this, scope);
 249         }
 250
 251         /*
 252          * (non-Javadoc)
 253          *
 254          * @see java.lang.Object#equals(java.lang.Object)
 255          */
 256         public boolean equals(Object obj) {
 257                 if (obj instanceof FieldDeclaration) {
 258                         char[] objName = ((FieldDeclaration) obj).name;
 259                         if (name.length != objName.length) {
 260                                 return false;
 261                         }
 262                         for (int i = 0; i < objName.length; i++) {
 263                                 if (name[i] != objName[i]) {
 264                                         return false;
 265                                 }
 266                         }
 267                         return true;
 268                 }
 269                 return super.equals(obj);
 270         }
 271 }