import eclipse 3.1 M4 compiler

[org.ibex.tool.git] / src / org / eclipse / jdt / internal / compiler / lookup / ArrayBinding.java

diff --git a/src/org/eclipse/jdt/internal/compiler/lookup/ArrayBinding.java b/src/org/eclipse/jdt/internal/compiler/lookup/ArrayBinding.java
index da45684..541002b 100644 (file)
--- a/src/org/eclipse/jdt/internal/compiler/lookup/ArrayBinding.java
+++ b/src/org/eclipse/jdt/internal/compiler/lookup/ArrayBinding.java
@@ -10,6 +10,7 @@
  *******************************************************************************/
 package org.eclipse.jdt.internal.compiler.lookup;
 
+import java.util.Map;
 import org.eclipse.jdt.core.compiler.CharOperation;
 import org.eclipse.jdt.internal.compiler.impl.Constant;
 
@@ -20,19 +21,56 @@ public final class ArrayBinding extends TypeBinding {
 
        public TypeBinding leafComponentType;
        public int dimensions;
-
+       LookupEnvironment environment;  
        char[] constantPoolName;
-public ArrayBinding(TypeBinding type, int dimensions) {
+       char[] genericTypeSignature;
+       
+public ArrayBinding(TypeBinding type, int dimensions, LookupEnvironment environment) {
        this.tagBits |= IsArrayType;
        this.leafComponentType = type;
        this.dimensions = dimensions;
+       this.environment = environment;
+       if (type instanceof UnresolvedReferenceBinding)
+               ((UnresolvedReferenceBinding) type).addWrapper(this);
+       else
+       this.tagBits |= type.tagBits & (HasTypeVariable | HasDirectWildcard);
+}
+
+public int kind() {
+       return ARRAY_TYPE;
+}
+
+/**
+ * Collect the substitutes into a map for certain type variables inside the receiver type
+ * e.g.   Collection<T>.findSubstitute(T, Collection<List<X>>):   T --> List<X>
+ */
+public void collectSubstitutes(TypeBinding otherType, Map substitutes) {
+    if (otherType.isArrayType()) {
+        int otherDim = otherType.dimensions();
+        if (otherDim == this.dimensions) {
+                   this.leafComponentType.collectSubstitutes(otherType.leafComponentType(), substitutes);
+        } else if (otherDim > this.dimensions) {
+            ArrayBinding otherReducedType = this.environment.createArrayType(otherType.leafComponentType(), otherDim - this.dimensions);
+            this.leafComponentType.collectSubstitutes(otherReducedType, substitutes);
+        }
+    } 
 }
+
+/*
+ * brakets leafUniqueKey
+ * p.X[][] --> [[Lp/X;
+ */
+public char[] computeUniqueKey() {
+       char[] brackets = new char[dimensions];
+       for (int i = dimensions - 1; i >= 0; i--) brackets[i] = '[';
+       return CharOperation.concat(brackets, this.leafComponentType.computeUniqueKey());
+ }
+       
 /**
  * Answer the receiver's constant pool name.
  * NOTE: This method should only be used during/after code gen.
  * e.g. '[Ljava/lang/Object;'
  */
-
 public char[] constantPoolName() {
        if (constantPoolName != null)
                return constantPoolName;
@@ -41,7 +79,7 @@ public char[] constantPoolName() {
        for (int i = dimensions - 1; i >= 0; i--) brackets[i] = '[';
        return constantPoolName = CharOperation.concat(brackets, leafComponentType.signature());
 }
-String debugName() {
+public String debugName() {
        StringBuffer brackets = new StringBuffer(dimensions * 2);
        for (int i = dimensions; --i >= 0;)
                brackets.append("[]"); //$NON-NLS-1$
@@ -56,16 +94,41 @@ public int dimensions() {
 * When the receiver's dimension size is one then answer the leaf component type.
 */
 
-public TypeBinding elementsType(Scope scope) {
-       if (dimensions == 1)    return leafComponentType;
-       return scope.createArray(leafComponentType, dimensions - 1);
+public TypeBinding elementsType() {
+       if (this.dimensions == 1) return this.leafComponentType;
+       return this.environment.createArrayType(this.leafComponentType, this.dimensions - 1);
 }
+/**
+ * @see org.eclipse.jdt.internal.compiler.lookup.TypeBinding#erasure()
+ */
+public TypeBinding erasure() {
+    TypeBinding erasedType = this.leafComponentType.erasure();
+    if (this.leafComponentType != erasedType)
+        return this.environment.createArrayType(erasedType, this.dimensions);
+    return this;
+}
+public LookupEnvironment environment() {
+    return this.environment;
+}
+
+public char[] genericTypeSignature() {
+       
+    if (this.genericTypeSignature == null) {
+               char[] brackets = new char[dimensions];
+               for (int i = dimensions - 1; i >= 0; i--) brackets[i] = '[';
+               this.genericTypeSignature = CharOperation.concat(brackets, leafComponentType.genericTypeSignature());
+    }
+    return this.genericTypeSignature;
+}
+
 public PackageBinding getPackage() {
        return leafComponentType.getPackage();
 }
+public int hashCode() {
+       return this.leafComponentType == null ? super.hashCode() : this.leafComponentType.hashCode();
+}
 /* Answer true if the receiver type can be assigned to the argument type (right)
 */
-
 public boolean isCompatibleWith(TypeBinding right) {
        if (this == right)
                return true;
@@ -81,6 +144,9 @@ public boolean isCompatibleWith(TypeBinding right) {
        } else {
                if (right.isBaseType())
                        return false;
+               if (right.isWildcard()) {
+                   return ((WildcardBinding) right).boundCheck(this);
+               }
        }
        //Check dimensions - Java does not support explicitly sized dimensions for types.
        //However, if it did, the type checking support would go here.
@@ -143,6 +209,12 @@ public char[] sourceName() {
        }
        return CharOperation.concat(leafComponentType.sourceName(), brackets);
 }
+public void swapUnresolved(UnresolvedReferenceBinding unresolvedType, ReferenceBinding resolvedType, LookupEnvironment env) {
+       if (this.leafComponentType == unresolvedType) {
+               this.leafComponentType = resolvedType.isGenericType() ? env.createRawType(resolvedType, resolvedType.enclosingType()) : resolvedType;
+               this.tagBits |= this.leafComponentType.tagBits & (HasTypeVariable | HasDirectWildcard);
+       }
+}
 public String toString() {
        return leafComponentType != null ? debugName() : "NULL TYPE ARRAY"; //$NON-NLS-1$
 }