2.4/dev/core/src/com/google/gwt/dev/jjs/impl/TypeMap.java

/*
 * Copyright 2008 Google Inc.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */
package com.google.gwt.dev.jjs.impl;

import com.google.gwt.dev.jjs.InternalCompilerException;
import com.google.gwt.dev.jjs.ast.JConstructor;
import com.google.gwt.dev.jjs.ast.JDeclaredType;
import com.google.gwt.dev.jjs.ast.JField;
import com.google.gwt.dev.jjs.ast.JMethod;
import com.google.gwt.dev.jjs.ast.JNode;
import com.google.gwt.dev.jjs.ast.JProgram;
import com.google.gwt.dev.jjs.ast.JType;
import com.google.gwt.dev.util.collect.IdentityHashSet;

import org.eclipse.jdt.internal.compiler.lookup.ArrayBinding;
import org.eclipse.jdt.internal.compiler.lookup.BaseTypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.BinaryTypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.Binding;
import org.eclipse.jdt.internal.compiler.lookup.FieldBinding;
import org.eclipse.jdt.internal.compiler.lookup.MethodBinding;
import org.eclipse.jdt.internal.compiler.lookup.ParameterizedFieldBinding;
import org.eclipse.jdt.internal.compiler.lookup.ParameterizedMethodBinding;
import org.eclipse.jdt.internal.compiler.lookup.ParameterizedTypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
import org.eclipse.jdt.internal.compiler.lookup.TypeVariableBinding;
import org.eclipse.jdt.internal.compiler.lookup.WildcardBinding;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.IdentityHashMap;
import java.util.List;
import java.util.Map;

/**
 * Contains the list of the top-level and array types.
 */
public class TypeMap {

  /**
   * Maps Eclipse AST nodes to our JNodes.
   */
  private final Map<Binding, JNode> crossRefMap = new IdentityHashMap<Binding, JNode>();

  private final Map<String, JDeclaredType> externalTypesByName =
      new HashMap<String, JDeclaredType>();

  /**
   * Centralizes creation and singleton management.
   */
  private final JProgram program;

  public TypeMap(JProgram program) {
    this.program = program;
  }

  public JNode get(Binding binding) {
    return get(binding, true);
  }

  public JProgram getProgram() {
    return program;
  }

  public void put(Binding binding, JNode to) {
    if (binding == null) {
      throw new InternalCompilerException("Trying to put null into typeMap.");
    }

    Object old = crossRefMap.put(binding, to);
    assert (old == null);

    if (to instanceof JDeclaredType) {
      JDeclaredType type = (JDeclaredType) to;
      if (type.isExternal()) {
        externalTypesByName.put(type.getName(), type);
      }
    }
  }

  public JNode tryGet(Binding binding) {
    return get(binding, false);
  }

  private boolean equals(MethodBinding binding, JMethod method) {
    if (!(method instanceof JConstructor && binding.isConstructor())
        && !method.getName().equals(String.valueOf(binding.constantPoolName()))) {
      return false;
    }

    List<JType> paramTypes = method.getOriginalParamTypes();
    TypeBinding[] bindingParams = binding.parameters;

    if (paramTypes.size() != bindingParams.length) {
      return false;
    }

    for (int i = 0; i < bindingParams.length; ++i) {
      TypeBinding bindingParam = bindingParams[i];
      if (paramTypes.get(i) != get(bindingParam)) {
        return false;
      }
    }

    return method.getType() == get(binding.returnType);
  }

  private JNode get(Binding binding, boolean failOnNull) {
    if (binding instanceof TypeVariableBinding) {
      TypeVariableBinding tvb = (TypeVariableBinding) binding;
      return get(tvb.erasure(), failOnNull);
    } else if (binding instanceof ParameterizedTypeBinding) {
      ParameterizedTypeBinding ptb = (ParameterizedTypeBinding) binding;
      return get(ptb.erasure(), failOnNull);
    } else if (binding instanceof ParameterizedMethodBinding) {
      ParameterizedMethodBinding pmb = (ParameterizedMethodBinding) binding;
      return get(pmb.original(), failOnNull);
    } else if (binding instanceof ParameterizedFieldBinding) {
      ParameterizedFieldBinding pfb = (ParameterizedFieldBinding) binding;
      return get(pfb.original(), failOnNull);
    } else if (binding instanceof WildcardBinding) {
      WildcardBinding wcb = (WildcardBinding) binding;
      return get(wcb.erasure(), failOnNull);
    }
    JNode result = internalGet(binding, failOnNull);
    if (result == null && failOnNull) {
      InternalCompilerException ice = new InternalCompilerException("Failed to get JNode");
      ice.addNode(binding.getClass().getName(), binding.toString(), null);
      throw ice;
    }
    return result;
  }

  private JField getFieldForBinding(JDeclaredType type, FieldBinding binding) {
    for (JField field : type.getFields()) {
      if (field.getName().equals(String.valueOf(binding.name))) {
        return field;
      }
    }

    return null;
  }

  private JMethod getMethodForBinding(JDeclaredType type, MethodBinding binding) {
    for (JMethod method : type.getMethods()) {
      if (equals(binding, method)) {
        return method;
      }
    }

    return null;
  }

  /**
   * Returns a list of JNodes that have the same name as the JDT Binding. This
   * method is only used during debugging sessions from the interactive
   * expression evaluator.
   */
  @SuppressWarnings("unused")
  private List<JNode> haveSameName(Binding binding) {
    IdentityHashSet<JNode> nodes = new IdentityHashSet<JNode>();
    for (Binding b : crossRefMap.keySet()) {
      if (String.valueOf(b.readableName()).equals(String.valueOf(binding.readableName()))) {
        nodes.add(crossRefMap.get(b));
      }
    }
    return new ArrayList<JNode>(nodes);
  }

  private JNode internalGet(Binding binding, boolean failOnNull) {
    JNode cached = crossRefMap.get(binding);
    if (cached != null) {
      return cached;
    } else if (binding instanceof BaseTypeBinding) {
      BaseTypeBinding baseTypeBinding = (BaseTypeBinding) binding;
      // see org.eclipse.jdt.internal.compiler.lookup.TypeIds constants
      switch (baseTypeBinding.id) {
        case TypeIds.T_JavaLangObject:
          // here for consistency, should already be cached
          return program.getTypeJavaLangObject();
        case TypeIds.T_char:
          return program.getTypePrimitiveChar();
        case TypeIds.T_byte:
          return program.getTypePrimitiveByte();
        case TypeIds.T_short:
          return program.getTypePrimitiveShort();
        case TypeIds.T_boolean:
          return program.getTypePrimitiveBoolean();
        case TypeIds.T_void:
          return program.getTypeVoid();
        case TypeIds.T_long:
          return program.getTypePrimitiveLong();
        case TypeIds.T_double:
          return program.getTypePrimitiveDouble();
        case TypeIds.T_float:
          return program.getTypePrimitiveFloat();
        case TypeIds.T_int:
          return program.getTypePrimitiveInt();
        case TypeIds.T_JavaLangString:
          // here for consistency, should already be cached
          return program.getTypeJavaLangString();
        case TypeIds.T_null:
          return program.getTypeNull();
        case TypeIds.T_undefined:
        default:
          return null;
      }
    } else if (binding instanceof ArrayBinding) {
      ArrayBinding arrayBinding = (ArrayBinding) binding;
      JType elementType = (JType) get(arrayBinding.elementsType(), failOnNull);
      if (elementType == null) {
        return null;
      }
      return program.getTypeArray(elementType);
    } else if (binding instanceof BinaryTypeBinding) {
      BinaryTypeBinding binaryBinding = (BinaryTypeBinding) binding;
      String name = BuildTypeMap.dotify(binaryBinding.compoundName);

      // There may be many BinaryTypeBindings for a single binary type
      JDeclaredType type = externalTypesByName.get(name);
      if (type != null) {
        put(binding, type);
      }
      return type;
    } else if (binding instanceof MethodBinding) {
      MethodBinding b = (MethodBinding) binding;
      JMethod cachedMethod = (JMethod) crossRefMap.get(b);
      if (cachedMethod == null) {
        JDeclaredType type = (JDeclaredType) get(b.declaringClass, failOnNull);
        if (type == null) {
          return type;
        }
        cachedMethod = getMethodForBinding(type, b);
        if (cachedMethod != null) {
          put(b, cachedMethod);
        }
      } else {
        // Happens sometimes when looking up the type to resolve the binding
        // causes us to also resolve the binding.
      }

      return cachedMethod;
    } else if (binding instanceof FieldBinding) {
      FieldBinding b = (FieldBinding) binding;
      JField cachedField = (JField) crossRefMap.get(b);

      if (cachedField == null) {
        JDeclaredType type = (JDeclaredType) get(b.declaringClass, failOnNull);
        if (type == null) {
          return null;
        }
        cachedField = getFieldForBinding(type, b);
        if (cachedField != null) {
          put(b, cachedField);
        }
      } else {
        // Happens sometimes when looking up the type to resolve the binding
        // causes us to also resolve the binding.
      }

      return cachedField;
    }

    return null;
  }
}