repo/org.ibex.tool/src/org/eclipse/jdt/internal/compiler/ast/TypeReference.java

   1 /*******************************************************************************
   2  * Copyright (c) 2000, 2004 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 org.eclipse.jdt.internal.compiler.ast;
  12
  13 import org.eclipse.jdt.internal.compiler.ASTVisitor;
  14 import org.eclipse.jdt.internal.compiler.flow.FlowContext;
  15 import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
  16 import org.eclipse.jdt.internal.compiler.lookup.*;
  17
  18 public abstract class TypeReference extends Expression {
  19
  20 public TypeReference() {
  21                 super () ;
  22                 }
  23
  24 public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {
  25         return flowInfo;
  26 }
  27
  28 // allows us to trap completion & selection nodes
  29 public void aboutToResolve(Scope scope) {
  30         // default implementation: do nothing
  31 }
  32 /*
  33  * Answer a base type reference (can be an array of base type).
  34  */
  35 public static final TypeReference baseTypeReference(int baseType, int dim) {
  36
  37         if (dim == 0) {
  38                 switch (baseType) {
  39                         case (T_void) :
  40                                 return new SingleTypeReference(VoidBinding.simpleName, 0);
  41                         case (T_boolean) :
  42                                 return new SingleTypeReference(BooleanBinding.simpleName, 0);
  43                         case (T_char) :
  44                                 return new SingleTypeReference(CharBinding.simpleName, 0);
  45                         case (T_float) :
  46                                 return new SingleTypeReference(FloatBinding.simpleName, 0);
  47                         case (T_double) :
  48                                 return new SingleTypeReference(DoubleBinding.simpleName, 0);
  49                         case (T_byte) :
  50                                 return new SingleTypeReference(ByteBinding.simpleName, 0);
  51                         case (T_short) :
  52                                 return new SingleTypeReference(ShortBinding.simpleName, 0);
  53                         case (T_int) :
  54                                 return new SingleTypeReference(IntBinding.simpleName, 0);
  55                         default : //T_long
  56                                 return new SingleTypeReference(LongBinding.simpleName, 0);
  57                 }
  58         }
  59         switch (baseType) {
  60                 case (T_void) :
  61                         return new ArrayTypeReference(VoidBinding.simpleName, dim, 0);
  62                 case (T_boolean) :
  63                         return new ArrayTypeReference(BooleanBinding.simpleName, dim, 0);
  64                 case (T_char) :
  65                         return new ArrayTypeReference(CharBinding.simpleName, dim, 0);
  66                 case (T_float) :
  67                         return new ArrayTypeReference(FloatBinding.simpleName, dim, 0);
  68                 case (T_double) :
  69                         return new ArrayTypeReference(DoubleBinding.simpleName, dim, 0);
  70                 case (T_byte) :
  71                         return new ArrayTypeReference(ByteBinding.simpleName, dim, 0);
  72                 case (T_short) :
  73                         return new ArrayTypeReference(ShortBinding.simpleName, dim, 0);
  74                 case (T_int) :
  75                         return new ArrayTypeReference(IntBinding.simpleName, dim, 0);
  76                 default : //T_long
  77                         return new ArrayTypeReference(LongBinding.simpleName, dim, 0);
  78         }
  79 }
  80 public abstract TypeReference copyDims(int dim);
  81 public int dimensions() {
  82         return 0;
  83 }
  84 public abstract TypeBinding getTypeBinding(Scope scope);
  85 /**
  86  * @return char[][]
  87  */
  88 public abstract char [][] getTypeName() ;
  89 public boolean isTypeReference() {
  90         return true;
  91 }
  92 public TypeBinding resolveType(BlockScope blockScope) {
  93         // handle the error here
  94         this.constant = NotAConstant;
  95         if (this.resolvedType != null) { // is a shared type reference which was already resolved
  96                 if (!this.resolvedType.isValidBinding())
  97                         return null; // already reported error
  98         } else {
  99                 this.resolvedType = getTypeBinding(blockScope);
 100                 if (!this.resolvedType.isValidBinding()) {
 101                         reportInvalidType(blockScope);
 102                         return null;
 103                 }
 104                 if (isTypeUseDeprecated(this.resolvedType, blockScope)) {
 105                         reportDeprecatedType(blockScope);
 106                 }
 107         }
 108         return this.resolvedType;
 109 }
 110
 111 public TypeBinding resolveType(ClassScope classScope) {
 112         // handle the error here
 113         this.constant = NotAConstant;
 114         if (this.resolvedType != null) { // is a shared type reference which was already resolved
 115                 if (!this.resolvedType.isValidBinding())
 116                         return null; // already reported error
 117         } else {
 118                 this.resolvedType = getTypeBinding(classScope);
 119                 if (!this.resolvedType.isValidBinding()) {
 120                         reportInvalidType(classScope);
 121                         return null;
 122                 }
 123                 if (isTypeUseDeprecated(this.resolvedType, classScope)) {
 124                         reportDeprecatedType(classScope);
 125                 }
 126         }
 127         return this.resolvedType;
 128 }
 129 protected void reportInvalidType(Scope scope) {
 130         scope.problemReporter().invalidType(this, this.resolvedType);
 131 }
 132 protected void reportDeprecatedType(Scope scope) {
 133         scope.problemReporter().deprecatedType(this.resolvedType, this);
 134 }
 135 public abstract void traverse(ASTVisitor visitor, ClassScope classScope);
 136 }