net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/ast/FieldDeclaration.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.ast;
  12
  13 import net.sourceforge.phpdt.internal.compiler.IAbstractSyntaxTreeVisitor;
  14 import net.sourceforge.phpdt.internal.compiler.impl.*;
  15 import net.sourceforge.phpdt.internal.compiler.codegen.*;
  16 import net.sourceforge.phpdt.internal.compiler.flow.*;
  17 import net.sourceforge.phpdt.internal.compiler.lookup.*;
  18
  19 public class FieldDeclaration extends AbstractVariableDeclaration {
  20         public FieldBinding binding;
  21         boolean hasBeenResolved = false;
  22
  23         //allows to retrieve both the "type" part of the declaration (part1)
  24         //and also the part that decribe the name and the init and optionally
  25         //some other dimension ! ....
  26         //public int[] a, b[] = X, c ;
  27         //for b that would give for
  28         // - part1 : public int[]
  29         // - part2 : b[] = X,
  30
  31         public int endPart1Position;
  32         public int endPart2Position;
  33
  34         public FieldDeclaration() {
  35         }
  36
  37         public FieldDeclaration(
  38                 Expression initialization,
  39                 char[] name,
  40                 int sourceStart,
  41                 int sourceEnd) {
  42
  43                 this.initialization = initialization;
  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 FlowInfo analyseCode(
  54                 MethodScope initializationScope,
  55                 FlowContext flowContext,
  56                 FlowInfo flowInfo) {
  57
  58                 // cannot define static non-constant field inside nested class
  59                 if (binding != null
  60                         && binding.isValidBinding()
  61                         && binding.isStatic()
  62                         && binding.constant == NotAConstant
  63                         && binding.declaringClass.isNestedType()
  64                         && binding.declaringClass.isClass()
  65                         && !binding.declaringClass.isStatic()) {
  66                         initializationScope.problemReporter().unexpectedStaticModifierForField(
  67                                 (SourceTypeBinding) binding.declaringClass,
  68                                 this);
  69                 }
  70
  71                 if (initialization != null) {
  72                         flowInfo =
  73                                 initialization
  74                                         .analyseCode(initializationScope, flowContext, flowInfo)
  75                                         .unconditionalInits();
  76                         flowInfo.markAsDefinitelyAssigned(binding);
  77                 } else {
  78                         flowInfo.markAsDefinitelyNotAssigned(binding);
  79                         // clear the bit in case it was already set (from enclosing info)
  80                 }
  81                 return flowInfo;
  82         }
  83
  84         /**
  85          * Code generation for a field declaration:
  86          *      i.e.&nbsp;normal assignment to a field
  87          *
  88          * @param currentScope org.eclipse.jdt.internal.compiler.lookup.BlockScope
  89          * @param codeStream org.eclipse.jdt.internal.compiler.codegen.CodeStream
  90          */
  91         public void generateCode(BlockScope currentScope, CodeStream codeStream) {
  92
  93                 if ((bits & IsReachableMASK) == 0) {
  94                         return;
  95                 }
  96                 // do not generate initialization code if final and static (constant is then
  97                 // recorded inside the field itself).
  98                 int pc = codeStream.position;
  99                 boolean isStatic;
 100                 if (initialization != null
 101                         && !((isStatic = binding.isStatic()) && binding.constant != NotAConstant)) {
 102                         // non-static field, need receiver
 103                         if (!isStatic)
 104                                 codeStream.aload_0();
 105                         // generate initialization value
 106                         initialization.generateCode(currentScope, codeStream, true);
 107                         // store into field
 108                         if (isStatic) {
 109                                 codeStream.putstatic(binding);
 110                         } else {
 111                                 codeStream.putfield(binding);
 112                         }
 113                 }
 114                 codeStream.recordPositionsFrom(pc, this.sourceStart);
 115         }
 116
 117         public TypeBinding getTypeBinding(Scope scope) {
 118
 119                 return type.getTypeBinding(scope);
 120         }
 121
 122         public boolean isField() {
 123
 124                 return true;
 125         }
 126
 127         public boolean isStatic() {
 128
 129                 if (binding != null)
 130                         return binding.isStatic();
 131                 return (modifiers & AccStatic) != 0;
 132         }
 133
 134         public String name() {
 135
 136                 return String.valueOf(name);
 137         }
 138
 139         public void resolve(MethodScope initializationScope) {
 140
 141                 // the two <constant = Constant.NotAConstant> could be regrouped into
 142                 // a single line but it is clearer to have two lines while the reason of their
 143                 // existence is not at all the same. See comment for the second one.
 144
 145                 //--------------------------------------------------------
 146                 if (!this.hasBeenResolved && binding != null && this.binding.isValidBinding()) {
 147
 148                         this.hasBeenResolved = true;
 149
 150                         if (isTypeUseDeprecated(this.binding.type, initializationScope))
 151                                 initializationScope.problemReporter().deprecatedType(this.binding.type, this.type);
 152
 153                         this.type.binding = this.binding.type; // update binding for type reference
 154
 155                         // the resolution of the initialization hasn't been done
 156                         if (this.initialization == null) {
 157                                 this.binding.constant = Constant.NotAConstant;
 158                         } else {
 159                                 int previous = initializationScope.fieldDeclarationIndex;
 160                                 try {
 161                                         initializationScope.fieldDeclarationIndex = this.binding.id;
 162
 163                                         // break dead-lock cycles by forcing constant to NotAConstant
 164                                         this.binding.constant = Constant.NotAConstant;
 165
 166                                         TypeBinding typeBinding = this.binding.type;
 167                                         TypeBinding initializationTypeBinding;
 168
 169                                         if (initialization instanceof ArrayInitializer) {
 170
 171                                                 if ((initializationTypeBinding = this.initialization.resolveTypeExpecting(initializationScope, typeBinding))    != null) {
 172                                                         ((ArrayInitializer) this.initialization).binding = (ArrayBinding) initializationTypeBinding;
 173                                                         this.initialization.implicitWidening(typeBinding, initializationTypeBinding);
 174                                                 }
 175                                         } else if ((initializationTypeBinding = initialization.resolveType(initializationScope)) != null) {
 176
 177                                                 if (this.initialization.isConstantValueOfTypeAssignableToType(initializationTypeBinding, typeBinding)
 178                                                         || (typeBinding.isBaseType() && BaseTypeBinding.isWidening(typeBinding.id, initializationTypeBinding.id))) {
 179
 180                                                         this.initialization.implicitWidening(typeBinding, initializationTypeBinding);
 181
 182                                                 }       else if (initializationScope.areTypesCompatible(initializationTypeBinding, typeBinding)) {
 183                                                         this.initialization.implicitWidening(typeBinding, initializationTypeBinding);
 184
 185                                                 } else {
 186                                                         initializationScope.problemReporter().typeMismatchError(initializationTypeBinding, typeBinding, this);
 187                                                 }
 188                                                 if (this.binding.isFinal()){ // cast from constant actual type to variable type
 189                                                         this.binding.constant =
 190                                                                 this.initialization.constant.castTo(
 191                                                                         (this.binding.type.id << 4) + 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(IAbstractSyntaxTreeVisitor 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 }