Removed fixed dependencies

packages/analyzer/lib/src/generated/testing/element_factory.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-library engine.testing.element_factory;
+library analyzer.src.generated.testing.element_factory;
 
 import 'dart:collection';
 
-import 'package:analyzer/src/generated/ast.dart';
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/token.dart';
+import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/dart/element/type.dart';
+import 'package:analyzer/src/dart/element/element.dart';
+import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/generated/constant.dart';
-import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
-import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/resolver.dart';
-import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/testing/ast_factory.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:path/path.dart';
 
 /**
  * The class `ElementFactory` defines utility methods used to create elements for testing
  * purposes. The elements that are created are complete in the sense that as much of the element
  * model as can be created, given the provided information, has been created.
  */
 class ElementFactory {
   /**
    * The element representing the class 'Object'.
    */
   static ClassElementImpl _objectElement;
 
   static ClassElementImpl get object {
     if (_objectElement == null) {
       _objectElement = classElement("Object", null);
     }
     return _objectElement;
   }
 
   static InterfaceType get objectType => object.type;
 
   static ClassElementImpl classElement(
       String typeName, InterfaceType superclassType,
       [List<String> parameterNames]) {
     ClassElementImpl element = new ClassElementImpl(typeName, 0);
+    element.constructors = const <ConstructorElement>[];
     element.supertype = superclassType;
-    InterfaceTypeImpl type = new InterfaceTypeImpl(element);
-    element.type = type;
     if (parameterNames != null) {
-      int count = parameterNames.length;
-      if (count > 0) {
-        List<TypeParameterElementImpl> typeParameters =
-            new List<TypeParameterElementImpl>(count);
-        List<TypeParameterTypeImpl> typeParameterTypes =
-            new List<TypeParameterTypeImpl>(count);
-        for (int i = 0; i < count; i++) {
-          TypeParameterElementImpl typeParameter =
-              typeParameterElement(parameterNames[i]);
-          typeParameters[i] = typeParameter;
-          typeParameterTypes[i] = new TypeParameterTypeImpl(typeParameter);
-          typeParameter.type = typeParameterTypes[i];
-        }
-        element.typeParameters = typeParameters;
-        type.typeArguments = typeParameterTypes;
-      }
+      element.typeParameters = typeParameters(parameterNames);
     }
     return element;
   }
 
   static ClassElementImpl classElement2(String typeName,
           [List<String> parameterNames]) =>
       classElement(typeName, objectType, parameterNames);
 
   static classTypeAlias(String typeName, InterfaceType superclassType,
       [List<String> parameterNames]) {
@@ skipping 19 matching lines @@
     unit.librarySource = librarySource;
     return unit;
   }
 
   static ConstLocalVariableElementImpl constLocalVariableElement(String name) =>
       new ConstLocalVariableElementImpl(name, 0);
 
   static ConstructorElementImpl constructorElement(
       ClassElement definingClass, String name, bool isConst,
       [List<DartType> argumentTypes]) {
-    DartType type = definingClass.type;
     ConstructorElementImpl constructor = name == null
         ? new ConstructorElementImpl("", -1)
         : new ConstructorElementImpl(name, 0);
+    if (name != null) {
+      if (name.isEmpty) {
+        constructor.nameEnd = definingClass.name.length;
+      } else {
+        constructor.periodOffset = definingClass.name.length;
+        constructor.nameEnd = definingClass.name.length + name.length + 1;
+      }
+    }
+    constructor.synthetic = name == null;
     constructor.const2 = isConst;
     if (argumentTypes != null) {
       int count = argumentTypes.length;
       List<ParameterElement> parameters = new List<ParameterElement>(count);
       for (int i = 0; i < count; i++) {
         ParameterElementImpl parameter = new ParameterElementImpl("a$i", i);
         parameter.type = argumentTypes[i];
         parameter.parameterKind = ParameterKind.REQUIRED;
         parameters[i] = parameter;
       }
       constructor.parameters = parameters;
     } else {
       constructor.parameters = <ParameterElement>[];
     }
-    constructor.returnType = type;
-    FunctionTypeImpl constructorType = new FunctionTypeImpl(constructor);
-    constructor.type = constructorType;
+    constructor.enclosingElement = definingClass;
+    if (!constructor.isSynthetic) {
+      constructor.constantInitializers = <ConstructorInitializer>[];
+    }
     return constructor;
   }
 
   static ConstructorElementImpl constructorElement2(
           ClassElement definingClass, String name,
           [List<DartType> argumentTypes]) =>
       constructorElement(definingClass, name, false, argumentTypes);
 
-  static ClassElementImpl enumElement(
-      TypeProvider typeProvider, String enumName,
+  static EnumElementImpl enumElement(TypeProvider typeProvider, String enumName,
       [List<String> constantNames]) {
     //
     // Build the enum.
     //
-    ClassElementImpl enumElement = new ClassElementImpl(enumName, -1);
-    InterfaceTypeImpl enumType = new InterfaceTypeImpl(enumElement);
-    enumElement.type = enumType;
-    enumElement.supertype = objectType;
-    enumElement.enum2 = true;
+    EnumElementImpl enumElement = new EnumElementImpl(enumName, -1);
+    InterfaceTypeImpl enumType = enumElement.type;
     //
     // Populate the fields.
     //
     List<FieldElement> fields = new List<FieldElement>();
     InterfaceType intType = typeProvider.intType;
     InterfaceType stringType = typeProvider.stringType;
     String indexFieldName = "index";
     FieldElementImpl indexField = new FieldElementImpl(indexFieldName, -1);
     indexField.final2 = true;
     indexField.type = intType;
     fields.add(indexField);
     String nameFieldName = "_name";
     FieldElementImpl nameField = new FieldElementImpl(nameFieldName, -1);
     nameField.final2 = true;
     nameField.type = stringType;
     fields.add(nameField);
     FieldElementImpl valuesField = new FieldElementImpl("values", -1);
     valuesField.static = true;
     valuesField.const3 = true;
-    valuesField.type = typeProvider.listType.substitute4(<DartType>[enumType]);
+    valuesField.type = typeProvider.listType.instantiate(<DartType>[enumType]);
     fields.add(valuesField);
     //
     // Build the enum constants.
     //
     if (constantNames != null) {
       int constantCount = constantNames.length;
       for (int i = 0; i < constantCount; i++) {
         String constantName = constantNames[i];
         FieldElementImpl constantElement =
             new ConstFieldElementImpl(constantName, -1);
@@ skipping 22 matching lines @@
   static ExportElementImpl exportFor(LibraryElement exportedLibrary,
       [List<NamespaceCombinator> combinators =
           NamespaceCombinator.EMPTY_LIST]) {
     ExportElementImpl spec = new ExportElementImpl(-1);
     spec.exportedLibrary = exportedLibrary;
     spec.combinators = combinators;
     return spec;
   }
 
   static FieldElementImpl fieldElement(
-      String name, bool isStatic, bool isFinal, bool isConst, DartType type) {
-    FieldElementImpl field = new FieldElementImpl(name, 0);
+      String name, bool isStatic, bool isFinal, bool isConst, DartType type,
+      {Expression initializer}) {
+    FieldElementImpl field = isConst
+        ? new ConstFieldElementImpl(name, 0)
+        : new FieldElementImpl(name, 0);
     field.const3 = isConst;
     field.final2 = isFinal;
     field.static = isStatic;
     field.type = type;
-    PropertyAccessorElementImpl getter =
-        new PropertyAccessorElementImpl.forVariable(field);
-    getter.getter = true;
-    getter.synthetic = true;
-    getter.variable = field;
-    getter.returnType = type;
-    field.getter = getter;
-    FunctionTypeImpl getterType = new FunctionTypeImpl(getter);
-    getter.type = getterType;
+    if (isConst) {
+      (field as ConstFieldElementImpl).constantInitializer = initializer;
+    }
+    new PropertyAccessorElementImpl_ImplicitGetter(field);
     if (!isConst && !isFinal) {
-      PropertyAccessorElementImpl setter =
-          new PropertyAccessorElementImpl.forVariable(field);
-      setter.setter = true;
-      setter.synthetic = true;
-      setter.variable = field;
-      setter.parameters = <ParameterElement>[
-        requiredParameter2("_$name", type)
-      ];
-      setter.returnType = VoidTypeImpl.instance;
-      setter.type = new FunctionTypeImpl(setter);
-      field.setter = setter;
+      new PropertyAccessorElementImpl_ImplicitSetter(field);
     }
     return field;
   }
 
   static FieldFormalParameterElementImpl fieldFormalParameter(
           Identifier name) =>
-      new FieldFormalParameterElementImpl(name);
+      new FieldFormalParameterElementImpl.forNode(name);
+
+  /**
+   * Destroy any static state retained by [ElementFactory].  This should be
+   * called from the `setUp` method of any tests that use [ElementFactory], in
+   * order to ensure that state is not shared between multiple tests.
+   */
+  static void flushStaticState() {
+    _objectElement = null;
+  }
 
   static FunctionElementImpl functionElement(String functionName) =>
       functionElement4(functionName, null, null, null, null);
 
   static FunctionElementImpl functionElement2(
-          String functionName, ClassElement returnElement) =>
+          String functionName, TypeDefiningElement returnElement) =>
       functionElement3(functionName, returnElement, null, null);
 
   static FunctionElementImpl functionElement3(
       String functionName,
-      ClassElement returnElement,
+      TypeDefiningElement returnElement,
       List<TypeDefiningElement> normalParameters,
       List<TypeDefiningElement> optionalParameters) {
     // We don't create parameter elements because we don't have parameter names
     FunctionElementImpl functionElement =
         new FunctionElementImpl(functionName, 0);
     FunctionTypeImpl functionType = new FunctionTypeImpl(functionElement);
     functionElement.type = functionType;
     // return type
     if (returnElement == null) {
       functionElement.returnType = VoidTypeImpl.instance;
@@ skipping 30 matching lines @@
       List<ClassElement> namedParameters) {
     FunctionElementImpl functionElement =
         new FunctionElementImpl(functionName, 0);
     FunctionTypeImpl functionType = new FunctionTypeImpl(functionElement);
     functionElement.type = functionType;
     // parameters
     int normalCount = normalParameters == null ? 0 : normalParameters.length;
     int nameCount = names == null ? 0 : names.length;
     int typeCount = namedParameters == null ? 0 : namedParameters.length;
     if (names != null && nameCount != typeCount) {
-      throw new IllegalStateException(
+      throw new StateError(
           "The passed String[] and ClassElement[] arrays had different lengths.");
     }
     int totalCount = normalCount + nameCount;
     List<ParameterElement> parameters = new List<ParameterElement>(totalCount);
     for (int i = 0; i < totalCount; i++) {
       if (i < normalCount) {
         ParameterElementImpl parameter = new ParameterElementImpl("a$i", i);
         parameter.type = normalParameters[i].type;
         parameter.parameterKind = ParameterKind.REQUIRED;
         parameters[i] = parameter;
@@ skipping 87 matching lines @@
         new FunctionTypeImpl.forTypedef(functionTypeAliasElement);
     return functionTypeAliasElement;
   }
 
   static PropertyAccessorElementImpl getterElement(
       String name, bool isStatic, DartType type) {
     FieldElementImpl field = new FieldElementImpl(name, -1);
     field.static = isStatic;
     field.synthetic = true;
     field.type = type;
+    field.final2 = true;
     PropertyAccessorElementImpl getter =
-        new PropertyAccessorElementImpl.forVariable(field);
+        new PropertyAccessorElementImpl(name, 0);
+    getter.synthetic = false;
     getter.getter = true;
     getter.variable = field;
     getter.returnType = type;
+    getter.static = isStatic;
     field.getter = getter;
     FunctionTypeImpl getterType = new FunctionTypeImpl(getter);
     getter.type = getterType;
     return getter;
   }
 
-  @deprecated
-  static HtmlElementImpl htmlUnit(AnalysisContext context, String fileName) {
-    Source source =
-        new NonExistingSource(fileName, toUri(fileName), UriKind.FILE_URI);
-    HtmlElementImpl unit = new HtmlElementImpl(context, fileName);
-    unit.source = source;
-    return unit;
-  }
-
   static ImportElementImpl importFor(
       LibraryElement importedLibrary, PrefixElement prefix,
       [List<NamespaceCombinator> combinators =
           NamespaceCombinator.EMPTY_LIST]) {
     ImportElementImpl spec = new ImportElementImpl(0);
     spec.importedLibrary = importedLibrary;
     spec.prefix = prefix;
     spec.combinators = combinators;
     return spec;
   }
@@ skipping 30 matching lines @@
       }
       method.parameters = parameters;
     }
     method.returnType = returnType;
     FunctionTypeImpl methodType = new FunctionTypeImpl(method);
     method.type = methodType;
     return method;
   }
 
   static MethodElementImpl methodElementWithParameters(
+      ClassElement enclosingElement,
       String methodName,
-      List<DartType> typeArguments,
       DartType returnType,
       List<ParameterElement> parameters) {
     MethodElementImpl method = new MethodElementImpl(methodName, 0);
+    method.enclosingElement = enclosingElement;
     method.parameters = parameters;
     method.returnType = returnType;
-    FunctionTypeImpl methodType = new FunctionTypeImpl(method);
-    methodType.typeArguments = typeArguments;
-    method.type = methodType;
+    method.type = new FunctionTypeImpl(method);
     return method;
   }
 
   static ParameterElementImpl namedParameter(String name) {
     ParameterElementImpl parameter = new ParameterElementImpl(name, 0);
     parameter.parameterKind = ParameterKind.NAMED;
     return parameter;
   }
 
   static ParameterElementImpl namedParameter2(String name, DartType type) {
     ParameterElementImpl parameter = new ParameterElementImpl(name, 0);
     parameter.parameterKind = ParameterKind.NAMED;
     parameter.type = type;
     return parameter;
   }
 
+  static ParameterElementImpl namedParameter3(String name,
+      {DartType type, Expression initializer, String initializerCode}) {
+    DefaultParameterElementImpl parameter =
+        new DefaultParameterElementImpl(name, 0);
+    parameter.parameterKind = ParameterKind.NAMED;
+    parameter.type = type;
+    parameter.constantInitializer = initializer;
+    parameter.defaultValueCode = initializerCode;
+    return parameter;
+  }
+
   static ParameterElementImpl positionalParameter(String name) {
     ParameterElementImpl parameter = new ParameterElementImpl(name, 0);
     parameter.parameterKind = ParameterKind.POSITIONAL;
     return parameter;
   }
 
   static ParameterElementImpl positionalParameter2(String name, DartType type) {
     ParameterElementImpl parameter = new ParameterElementImpl(name, 0);
     parameter.parameterKind = ParameterKind.POSITIONAL;
     parameter.type = type;
@@ skipping 16 matching lines @@
     return parameter;
   }
 
   static PropertyAccessorElementImpl setterElement(
       String name, bool isStatic, DartType type) {
     FieldElementImpl field = new FieldElementImpl(name, -1);
     field.static = isStatic;
     field.synthetic = true;
     field.type = type;
     PropertyAccessorElementImpl getter =
-        new PropertyAccessorElementImpl.forVariable(field);
+        new PropertyAccessorElementImpl(name, -1);
     getter.getter = true;
     getter.variable = field;
     getter.returnType = type;
     field.getter = getter;
     FunctionTypeImpl getterType = new FunctionTypeImpl(getter);
     getter.type = getterType;
     ParameterElementImpl parameter = requiredParameter2("a", type);
     PropertyAccessorElementImpl setter =
-        new PropertyAccessorElementImpl.forVariable(field);
+        new PropertyAccessorElementImpl(name, -1);
     setter.setter = true;
     setter.synthetic = true;
     setter.variable = field;
     setter.parameters = <ParameterElement>[parameter];
     setter.returnType = VoidTypeImpl.instance;
     setter.type = new FunctionTypeImpl(setter);
     field.setter = setter;
     return setter;
   }
 
   static TopLevelVariableElementImpl topLevelVariableElement(Identifier name) =>
       new TopLevelVariableElementImpl.forNode(name);
 
   static TopLevelVariableElementImpl topLevelVariableElement2(String name) =>
       topLevelVariableElement3(name, false, false, null);
 
   static TopLevelVariableElementImpl topLevelVariableElement3(
       String name, bool isConst, bool isFinal, DartType type) {
     TopLevelVariableElementImpl variable;
     if (isConst) {
       ConstTopLevelVariableElementImpl constant =
-          new ConstTopLevelVariableElementImpl(AstFactory.identifier3(name));
-      constant.constantInitializer = AstFactory.instanceCreationExpression2(
-          Keyword.CONST, AstFactory.typeName(type.element));
+          new ConstTopLevelVariableElementImpl.forNode(
+              AstFactory.identifier3(name));
+      InstanceCreationExpression initializer =
+          AstFactory.instanceCreationExpression2(
+              Keyword.CONST, AstFactory.typeName(type.element));
+      if (type is InterfaceType) {
+        ConstructorElement element = type.element.unnamedConstructor;
+        initializer.staticElement = element;
+        initializer.constructorName.staticElement = element;
+      }
+      constant.constantInitializer = initializer;
       variable = constant;
     } else {
       variable = new TopLevelVariableElementImpl(name, -1);
     }
     variable.const3 = isConst;
     variable.final2 = isFinal;
-    variable.synthetic = true;
-    PropertyAccessorElementImpl getter =
-        new PropertyAccessorElementImpl.forVariable(variable);
-    getter.getter = true;
-    getter.synthetic = true;
-    getter.variable = variable;
-    getter.returnType = type;
-    variable.getter = getter;
-    FunctionTypeImpl getterType = new FunctionTypeImpl(getter);
-    getter.type = getterType;
+    variable.synthetic = false;
+    variable.type = type;
+    new PropertyAccessorElementImpl_ImplicitGetter(variable);
     if (!isConst && !isFinal) {
-      PropertyAccessorElementImpl setter =
-          new PropertyAccessorElementImpl.forVariable(variable);
-      setter.setter = true;
-      setter.static = true;
-      setter.synthetic = true;
-      setter.variable = variable;
-      setter.parameters = <ParameterElement>[
-        requiredParameter2("_$name", type)
-      ];
-      setter.returnType = VoidTypeImpl.instance;
-      setter.type = new FunctionTypeImpl(setter);
-      variable.setter = setter;
+      new PropertyAccessorElementImpl_ImplicitSetter(variable);
     }
     return variable;
   }
 
   static TypeParameterElementImpl typeParameterElement(String name) {
     TypeParameterElementImpl element = new TypeParameterElementImpl(name, 0);
     element.type = new TypeParameterTypeImpl(element);
     return element;
   }
+
+  static List<TypeParameterElement> typeParameters(List<String> names) {
+    int count = names.length;
+    if (count == 0) {
+      return TypeParameterElement.EMPTY_LIST;
+    }
+    List<TypeParameterElementImpl> typeParameters =
+        new List<TypeParameterElementImpl>(count);
+    for (int i = 0; i < count; i++) {
+      typeParameters[i] = typeParameterWithType(names[i]);
+    }
+    return typeParameters;
+  }
+
+  static TypeParameterElementImpl typeParameterWithType(String name,
+      [DartType bound]) {
+    TypeParameterElementImpl typeParameter = typeParameterElement(name);
+    typeParameter.type = new TypeParameterTypeImpl(typeParameter);
+    typeParameter.bound = bound;
+    return typeParameter;
+  }
 }