dart/editor/tools/plugins/com.google.dart.engine_test/src/com/google/dart/engine/internal/resolver/TestTypeProvider.java

/*
 * Copyright (c) 2013, the Dart project authors.
 * 
 * Licensed under the Eclipse Public License v1.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.eclipse.org/legal/epl-v10.html
 * 
 * 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.dart.engine.internal.resolver;

import com.google.dart.engine.element.ConstructorElement;
import com.google.dart.engine.element.FieldElement;
import com.google.dart.engine.element.MethodElement;
import com.google.dart.engine.element.ParameterElement;
import com.google.dart.engine.element.PropertyAccessorElement;
import com.google.dart.engine.internal.element.ClassElementImpl;
import com.google.dart.engine.internal.element.ConstructorElementImpl;
import com.google.dart.engine.internal.type.BottomTypeImpl;
import com.google.dart.engine.internal.type.DynamicTypeImpl;
import com.google.dart.engine.internal.type.FunctionTypeImpl;
import com.google.dart.engine.internal.type.TypeParameterTypeImpl;
import com.google.dart.engine.internal.type.VoidTypeImpl;
import com.google.dart.engine.type.InterfaceType;
import com.google.dart.engine.type.Type;

import static com.google.dart.engine.element.ElementFactory.classElement;
import static com.google.dart.engine.element.ElementFactory.constructorElement;
import static com.google.dart.engine.element.ElementFactory.fieldElement;
import static com.google.dart.engine.element.ElementFactory.getObject;
import static com.google.dart.engine.element.ElementFactory.getterElement;
import static com.google.dart.engine.element.ElementFactory.methodElement;
import static com.google.dart.engine.element.ElementFactory.namedParameter;
import static com.google.dart.engine.element.ElementFactory.requiredParameter;

/**
 * Instances of the class {@code TestTypeProvider} implement a type provider that can be used by
 * tests without creating the element model for the core library.
 */
public class TestTypeProvider implements TypeProvider {
  /**
   * The type representing the built-in type 'bool'.
   */
  private InterfaceType boolType;

  /**
   * The type representing the type 'bottom'.
   */
  private Type bottomType;

  /**
   * The type representing the built-in type 'double'.
   */
  private InterfaceType doubleType;

  /**
   * The type representing the built-in type 'deprecated'.
   */
  private InterfaceType deprecatedType;

  /**
   * The type representing the built-in type 'dynamic'.
   */
  private Type dynamicType;

  /**
   * The type representing the built-in type 'Function'.
   */
  private InterfaceType functionType;

  /**
   * The type representing the built-in type 'int'.
   */
  private InterfaceType intType;

  /**
   * The type representing 'Iterable<dynamic>'
   */
  private InterfaceType iterableDynamicType;

  /**
   * The type representing the built-in type 'Iterable'.
   */
  private InterfaceType iterableType;

  /**
   * The type representing the built-in type 'Iterator'.
   */
  private InterfaceType iteratorType;

  /**
   * The type representing the built-in type 'List'.
   */
  private InterfaceType listType;

  /**
   * The type representing the built-in type 'Map'.
   */
  private InterfaceType mapType;

  /**
   * The type representing the built-in type 'Null'.
   */
  private InterfaceType nullType;

  /**
   * The type representing the built-in type 'num'.
   */
  private InterfaceType numType;

  /**
   * The type representing the built-in type 'Object'.
   */
  private InterfaceType objectType;

  /**
   * The type representing the built-in type 'StackTrace'.
   */
  private InterfaceType stackTraceType;

  /**
   * The type representing the built-in type 'String'.
   */
  private InterfaceType stringType;

  /**
   * The type representing the built-in type 'Symbol'.
   */
  private InterfaceType symbolType;

  /**
   * The type representing the built-in type 'Type'.
   */
  private InterfaceType typeType;

  /**
   * Initialize a newly created type provider to provide stand-ins for the types defined in the core
   * library.
   */
  public TestTypeProvider() {
    super();
  }

  @Override
  public InterfaceType getBoolType() {
    if (boolType == null) {
      ClassElementImpl boolElement = classElement("bool");
      boolType = boolElement.getType();
      ConstructorElementImpl fromEnvironment = constructorElement(
          boolElement,
          "fromEnvironment",
          true);
      fromEnvironment.setParameters(new ParameterElement[] {
          requiredParameter("name", getStringType()), namedParameter("defaultValue", boolType)});
      fromEnvironment.setFactory(true);
      boolElement.setConstructors(new ConstructorElement[] {fromEnvironment});
    }
    return boolType;
  }

  @Override
  public Type getBottomType() {
    if (bottomType == null) {
      bottomType = BottomTypeImpl.getInstance();
    }
    return bottomType;
  }

  @Override
  public InterfaceType getDeprecatedType() {
    if (deprecatedType == null) {
      ClassElementImpl deprecatedElement = classElement("Deprecated");
      deprecatedElement.setConstructors(new ConstructorElement[] {constructorElement(
          deprecatedElement,
          null,
          true,
          getStringType())});
      deprecatedType = deprecatedElement.getType();
    }
    return deprecatedType;
  }

  @Override
  public InterfaceType getDoubleType() {
    if (doubleType == null) {
      initializeNumericTypes();
    }
    return doubleType;
  }

  @Override
  public Type getDynamicType() {
    if (dynamicType == null) {
      dynamicType = DynamicTypeImpl.getInstance();
    }
    return dynamicType;
  }

  @Override
  public InterfaceType getFunctionType() {
    if (functionType == null) {
      functionType = classElement("Function").getType();
    }
    return functionType;
  }

  @Override
  public InterfaceType getIntType() {
    if (intType == null) {
      initializeNumericTypes();
    }
    return intType;
  }

  @Override
  public InterfaceType getIterableDynamicType() {
    if (iterableDynamicType == null) {
      iterableDynamicType = getIterableType().substitute(new Type[] {getDynamicType()});
    }
    return iterableDynamicType;
  }

  @Override
  public InterfaceType getIterableType() {
    if (iterableType == null) {
      ClassElementImpl iterableElement = classElement("Iterable", "E");
      iterableType = iterableElement.getType();
      Type eType = iterableElement.getTypeParameters()[0].getType();
      iterableElement.setAccessors(new PropertyAccessorElement[] {//
          getterElement("iterator", false, getIteratorType().substitute(new Type[] {eType})),
          getterElement("last", false, eType),});
      propagateTypeArguments(iterableElement);
    }
    return iterableType;
  }

  public InterfaceType getIteratorType() {
    if (iteratorType == null) {
      ClassElementImpl iteratorElement = classElement("Iterator", "E");
      iteratorType = iteratorElement.getType();
      Type eType = iteratorElement.getTypeParameters()[0].getType();
      iteratorElement.setAccessors(new PropertyAccessorElement[] {//
      getterElement("current", false, eType),});
      propagateTypeArguments(iteratorElement);
    }
    return iteratorType;
  }

  @Override
  public InterfaceType getListType() {
    if (listType == null) {
      ClassElementImpl listElement = classElement("List", "E");
      listElement.setConstructors(new ConstructorElement[] {constructorElement(listElement, null)});
      listType = listElement.getType();
      Type eType = listElement.getTypeParameters()[0].getType();
      InterfaceType iterableType = getIterableType().substitute(new Type[] {eType});
      listElement.setInterfaces(new InterfaceType[] {iterableType});
      listElement.setAccessors(new PropertyAccessorElement[] {getterElement(
          "length",
          false,
          getIntType())});
      listElement.setMethods(new MethodElement[] {
          methodElement("[]", eType, getIntType()),
          methodElement("[]=", VoidTypeImpl.getInstance(), getIntType(), eType),
          methodElement("add", VoidTypeImpl.getInstance(), eType)});
      propagateTypeArguments(listElement);
    }
    return listType;
  }

  @Override
  public InterfaceType getMapType() {
    if (mapType == null) {
      ClassElementImpl mapElement = classElement("Map", "K", "V");
      mapType = mapElement.getType();
      Type kType = mapElement.getTypeParameters()[0].getType();
      Type vType = mapElement.getTypeParameters()[1].getType();
      mapElement.setAccessors(new PropertyAccessorElement[] {getterElement(
          "length",
          false,
          getIntType())});
      mapElement.setMethods(new MethodElement[] {
          methodElement("[]", vType, getObjectType()),
          methodElement("[]=", VoidTypeImpl.getInstance(), kType, vType)});
      propagateTypeArguments(mapElement);
    }
    return mapType;
  }

  @Override
  public InterfaceType getNullType() {
    if (nullType == null) {
      nullType = classElement("Null").getType();
    }
    return nullType;
  }

  @Override
  public InterfaceType getNumType() {
    if (numType == null) {
      initializeNumericTypes();
    }
    return numType;
  }

  @Override
  public InterfaceType getObjectType() {
    if (objectType == null) {
      ClassElementImpl objectElement = getObject();
      objectType = objectElement.getType();
      objectElement.setConstructors(new ConstructorElement[] {constructorElement(
          objectElement,
          null)});
      objectElement.setMethods(new MethodElement[] {
          methodElement("toString", getStringType()),
          methodElement("==", getBoolType(), objectType),
          methodElement("noSuchMethod", getDynamicType(), getDynamicType())});
      objectElement.setAccessors(new PropertyAccessorElement[] {
          getterElement("hashCode", false, getIntType()),
          getterElement("runtimeType", false, getTypeType())});
    }
    return objectType;
  }

  @Override
  public InterfaceType getStackTraceType() {
    if (stackTraceType == null) {
      stackTraceType = classElement("StackTrace").getType();
    }
    return stackTraceType;
  }

  @Override
  public InterfaceType getStringType() {
    if (stringType == null) {
      stringType = classElement("String").getType();
      ClassElementImpl stringElement = (ClassElementImpl) stringType.getElement();
      stringElement.setAccessors(new PropertyAccessorElement[] {//
          getterElement("isEmpty", false, getBoolType()),
          getterElement("length", false, getIntType()),
          getterElement("codeUnits", false, getListType().substitute(new Type[] {getIntType()}))});
      stringElement.setMethods(new MethodElement[] {
          methodElement("+", stringType, stringType), methodElement("toLowerCase", stringType),
          methodElement("toUpperCase", stringType)});
      ConstructorElementImpl fromEnvironment = constructorElement(
          stringElement,
          "fromEnvironment",
          true);
      fromEnvironment.setParameters(new ParameterElement[] {
          requiredParameter("name", getStringType()), namedParameter("defaultValue", stringType)});
      fromEnvironment.setFactory(true);
      stringElement.setConstructors(new ConstructorElement[] {fromEnvironment});
    }
    return stringType;
  }

  @Override
  public InterfaceType getSymbolType() {
    if (symbolType == null) {
      ClassElementImpl symbolClass = classElement("Symbol");
      ConstructorElementImpl constructor = constructorElement(
          symbolClass,
          null,
          true,
          getStringType());
      constructor.setFactory(true);
      symbolClass.setConstructors(new ConstructorElement[] {constructor});
      symbolType = symbolClass.getType();
    }
    return symbolType;
  }

  @Override
  public InterfaceType getTypeType() {
    if (typeType == null) {
      typeType = classElement("Type").getType();
    }
    return typeType;
  }

  /**
   * Initialize the numeric types. They are created as a group so that we can (a) create the right
   * hierarchy and (b) add members to them.
   */
  private void initializeNumericTypes() {
    //
    // Create the type hierarchy.
    //
    ClassElementImpl numElement = classElement("num");
    numType = numElement.getType();

    ClassElementImpl intElement = classElement("int", numType);
    intType = intElement.getType();

    ClassElementImpl doubleElement = classElement("double", numType);
    doubleType = doubleElement.getType();
    //
    // Force the referenced types to be cached.
    //
    getObjectType();
    getBoolType();
    getStringType();
    //
    // Add the methods.
    //
    numElement.setMethods(new MethodElement[] {
        methodElement("+", numType, numType), methodElement("-", numType, numType),
        methodElement("*", numType, numType), methodElement("%", numType, numType),
        methodElement("/", doubleType, numType), methodElement("~/", numType, numType),
        methodElement("-", numType), methodElement("remainder", numType, numType),
        methodElement("<", boolType, numType), methodElement("<=", boolType, numType),
        methodElement(">", boolType, numType), methodElement(">=", boolType, numType),
        methodElement("==", boolType, objectType), methodElement("isNaN", boolType),
        methodElement("isNegative", boolType), methodElement("isInfinite", boolType),
        methodElement("abs", numType), methodElement("floor", numType),
        methodElement("ceil", numType), methodElement("round", numType),
        methodElement("truncate", numType), methodElement("toInt", intType),
        methodElement("toDouble", doubleType),
        methodElement("toStringAsFixed", stringType, intType),
        methodElement("toStringAsExponential", stringType, intType),
        methodElement("toStringAsPrecision", stringType, intType),
        methodElement("toRadixString", stringType, intType),});
    intElement.setMethods(new MethodElement[] {
        methodElement("&", intType, intType),
        methodElement("|", intType, intType),
        methodElement("^", intType, intType),
        methodElement("~", intType),
        methodElement("<<", intType, intType),
        methodElement(">>", intType, intType),
//      getterElement("isEven", boolType),
//      getterElement("isOdd", boolType),
        methodElement("-", intType), methodElement("abs", intType),
        methodElement("round", intType), methodElement("floor", intType),
        methodElement("ceil", intType), methodElement("truncate", intType),
        methodElement("toString", stringType),
//      methodElement(/*external static*/ "parse", intType, stringType),
    });
    ConstructorElementImpl fromEnvironment = constructorElement(intElement, "fromEnvironment", true);
    fromEnvironment.setParameters(new ParameterElement[] {
        requiredParameter("name", getStringType()), namedParameter("defaultValue", intType)});
    fromEnvironment.setFactory(true);
    intElement.setConstructors(new ConstructorElement[] {fromEnvironment});
    FieldElement[] fields = new FieldElement[] {fieldElement("NAN", true, false, true, doubleType), // 0.0 / 0.0
        fieldElement("INFINITY", true, false, true, doubleType), // 1.0 / 0.0
        fieldElement("NEGATIVE_INFINITY", true, false, true, doubleType), // -INFINITY
        fieldElement("MIN_POSITIVE", true, false, true, doubleType), // 5e-324
        fieldElement("MAX_FINITE", true, false, true, doubleType), // 1.7976931348623157e+308;
    };
    doubleElement.setFields(fields);
    int fieldCount = fields.length;
    PropertyAccessorElement[] accessors = new PropertyAccessorElement[fieldCount];
    for (int i = 0; i < fieldCount; i++) {
      accessors[i] = fields[i].getGetter();
    }
    doubleElement.setAccessors(accessors);
    doubleElement.setMethods(new MethodElement[] {
        methodElement("remainder", doubleType, numType), methodElement("+", doubleType, numType),
        methodElement("-", doubleType, numType), methodElement("*", doubleType, numType),
        methodElement("%", doubleType, numType), methodElement("/", doubleType, numType),
        methodElement("~/", doubleType, numType), methodElement("-", doubleType),
        methodElement("abs", doubleType), methodElement("round", doubleType),
        methodElement("floor", doubleType), methodElement("ceil", doubleType),
        methodElement("truncate", doubleType), methodElement("toString", stringType),
//      methodElement(/*external static*/ "parse", doubleType, stringType),
    });
  }

  /**
   * Given a class element representing a class with type parameters, propagate those type
   * parameters to all of the accessors, methods and constructors defined for the class.
   * 
   * @param classElement the element representing the class with type parameters
   */
  private void propagateTypeArguments(ClassElementImpl classElement) {
    Type[] typeArguments = TypeParameterTypeImpl.getTypes(classElement.getTypeParameters());
    for (PropertyAccessorElement accessor : classElement.getAccessors()) {
      FunctionTypeImpl functionType = (FunctionTypeImpl) accessor.getType();
      functionType.setTypeArguments(typeArguments);
    }
    for (MethodElement method : classElement.getMethods()) {
      FunctionTypeImpl functionType = (FunctionTypeImpl) method.getType();
      functionType.setTypeArguments(typeArguments);
    }
    for (ConstructorElement constructor : classElement.getConstructors()) {
      FunctionTypeImpl functionType = (FunctionTypeImpl) constructor.getType();
      functionType.setTypeArguments(typeArguments);
    }
  }
}