Push new analyzer-experimental with Resolver and ResolverTest.

pkg/analyzer-experimental/test/generated/element_test.dart

 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.element_test;
 
 import 'dart:collection';
 import 'dart:io';
 import 'package:analyzer-experimental/src/generated/java_core.dart';
 import 'package:analyzer-experimental/src/generated/java_engine.dart';
 import 'package:analyzer-experimental/src/generated/java_engine_io.dart';
@@ skipping 109 matching lines @@
     library18.imports = imports;
     List<PrefixElement> prefixes2 = library18.prefixes;
     EngineTestCase.assertLength(2, prefixes2);
     if (identical(prefixA, prefixes2[0])) {
       JUnitTestCase.assertSame(prefixB, prefixes2[1]);
     } else {
       JUnitTestCase.assertSame(prefixB, prefixes2[0]);
       JUnitTestCase.assertSame(prefixA, prefixes2[1]);
     }
   }
+  void test_isUpToDate() {
+    AnalysisContext context = new AnalysisContextImpl();
+    context.sourceFactory = new SourceFactory.con2([]);
+    LibraryElement library19 = ElementFactory.library(context, "foo");
+    context.sourceFactory.setContents(library19.definingCompilationUnit.source, "sdfsdff");
+    JUnitTestCase.assertFalse(library19.isUpToDate2(0));
+    JUnitTestCase.assertTrue(library19.isUpToDate2(JavaSystem.currentTimeMillis() + 1000));
+  }
   void test_setImports() {
     AnalysisContext context = new AnalysisContextImpl();
     LibraryElementImpl library = new LibraryElementImpl(context, ASTFactory.libraryIdentifier2(["l1"]));
     List<ImportElementImpl> expectedImports = [ElementFactory.importFor(ElementFactory.library(context, "l2"), null, []), ElementFactory.importFor(ElementFactory.library(context, "l3"), null, [])];
     library.imports = expectedImports;
     List<ImportElement> actualImports = library.imports;
     EngineTestCase.assertLength(expectedImports.length, actualImports);
     for (int i = 0; i < actualImports.length; i++) {
       JUnitTestCase.assertSame(expectedImports[i], actualImports[i]);
     }
   }
   static dartSuite() {
     _ut.group('LibraryElementImplTest', () {
       _ut.test('test_creation', () {
         final __test = new LibraryElementImplTest();
         runJUnitTest(__test, __test.test_creation);
       });
       _ut.test('test_getImportedLibraries', () {
         final __test = new LibraryElementImplTest();
         runJUnitTest(__test, __test.test_getImportedLibraries);
       });
       _ut.test('test_getPrefixes', () {
         final __test = new LibraryElementImplTest();
         runJUnitTest(__test, __test.test_getPrefixes);
       });
+      _ut.test('test_isUpToDate', () {
+        final __test = new LibraryElementImplTest();
+        runJUnitTest(__test, __test.test_isUpToDate);
+      });
       _ut.test('test_setImports', () {
         final __test = new LibraryElementImplTest();
         runJUnitTest(__test, __test.test_setImports);
       });
     });
   }
 }
 class InterfaceTypeImplTest extends EngineTestCase {
   void test_computeLongestInheritancePathToObject_multipleInterfacePaths() {
     ClassElementImpl elementA = ElementFactory.classElement2("A", []);
@@ skipping 330 matching lines @@
   }
   void test_isDirectSupertypeOf_with() {
     ClassElementImpl elementA = ElementFactory.classElement2("A", []);
     ClassElementImpl elementB = ElementFactory.classElement2("B", []);
     elementB.mixins = <InterfaceType> [elementA.type];
     InterfaceTypeImpl typeA = new InterfaceTypeImpl.con1(elementA);
     InterfaceTypeImpl typeB = new InterfaceTypeImpl.con1(elementB);
     JUnitTestCase.assertTrue(typeA.isDirectSupertypeOf(typeB));
   }
   void test_isMoreSpecificThan_bottom() {
-    Type2 type24 = ElementFactory.classElement2("A", []).type;
-    JUnitTestCase.assertTrue(BottomTypeImpl.instance.isMoreSpecificThan(type24));
+    Type2 type25 = ElementFactory.classElement2("A", []).type;
+    JUnitTestCase.assertTrue(BottomTypeImpl.instance.isMoreSpecificThan(type25));
   }
   void test_isMoreSpecificThan_covariance() {
     ClassElement elementA = ElementFactory.classElement2("A", ["E"]);
     ClassElement elementI = ElementFactory.classElement2("I", []);
     ClassElement elementJ = ElementFactory.classElement("J", elementI.type, []);
     InterfaceTypeImpl typeAI = new InterfaceTypeImpl.con1(elementA);
     InterfaceTypeImpl typeAJ = new InterfaceTypeImpl.con1(elementA);
     typeAI.typeArguments = <Type2> [elementI.type];
     typeAJ.typeArguments = <Type2> [elementJ.type];
     JUnitTestCase.assertTrue(typeAJ.isMoreSpecificThan(typeAI));
     JUnitTestCase.assertFalse(typeAI.isMoreSpecificThan(typeAJ));
   }
   void test_isMoreSpecificThan_directSupertype() {
     ClassElement elementA = ElementFactory.classElement2("A", []);
     ClassElement elementB = ElementFactory.classElement("B", elementA.type, []);
     InterfaceType typeA = elementA.type;
     InterfaceType typeB = elementB.type;
     JUnitTestCase.assertTrue(typeB.isMoreSpecificThan(typeA));
     JUnitTestCase.assertFalse(typeA.isMoreSpecificThan(typeB));
   }
   void test_isMoreSpecificThan_dynamic() {
-    InterfaceType type25 = ElementFactory.classElement2("A", []).type;
-    JUnitTestCase.assertTrue(type25.isMoreSpecificThan(DynamicTypeImpl.instance));
+    InterfaceType type26 = ElementFactory.classElement2("A", []).type;
+    JUnitTestCase.assertTrue(type26.isMoreSpecificThan(DynamicTypeImpl.instance));
   }
   void test_isMoreSpecificThan_indirectSupertype() {
     ClassElement elementA = ElementFactory.classElement2("A", []);
     ClassElement elementB = ElementFactory.classElement("B", elementA.type, []);
     ClassElement elementC = ElementFactory.classElement("C", elementB.type, []);
     InterfaceType typeA = elementA.type;
     InterfaceType typeC = elementC.type;
     JUnitTestCase.assertTrue(typeC.isMoreSpecificThan(typeA));
   }
   void test_isMoreSpecificThan_self() {
-    InterfaceType type26 = ElementFactory.classElement2("A", []).type;
-    JUnitTestCase.assertTrue(type26.isMoreSpecificThan(type26));
+    InterfaceType type27 = ElementFactory.classElement2("A", []).type;
+    JUnitTestCase.assertTrue(type27.isMoreSpecificThan(type27));
   }
   void test_isSubtypeOf_directSubtype() {
     ClassElement elementA = ElementFactory.classElement2("A", []);
     ClassElement elementB = ElementFactory.classElement("B", elementA.type, []);
     InterfaceType typeA = elementA.type;
     InterfaceType typeB = elementB.type;
     JUnitTestCase.assertTrue(typeB.isSubtypeOf(typeA));
     JUnitTestCase.assertFalse(typeA.isSubtypeOf(typeB));
   }
   void test_isSubtypeOf_dynamic() {
@@ skipping 132 matching lines @@
     InterfaceType typeObject = elementA.supertype;
     JUnitTestCase.assertFalse(typeA.isSupertypeOf(typeObject));
     JUnitTestCase.assertTrue(typeObject.isSupertypeOf(typeA));
   }
   void test_isSupertypeOf_self() {
     ClassElement elementA = ElementFactory.classElement2("A", []);
     InterfaceType typeA = elementA.type;
     JUnitTestCase.assertTrue(typeA.isSupertypeOf(typeA));
   }
   void test_setTypeArguments() {
-    InterfaceTypeImpl type27 = ElementFactory.classElement2("A", []).type as InterfaceTypeImpl;
+    InterfaceTypeImpl type28 = ElementFactory.classElement2("A", []).type as InterfaceTypeImpl;
     List<Type2> typeArguments = <Type2> [new InterfaceTypeImpl.con1(ElementFactory.classElement2("B", [])), new InterfaceTypeImpl.con1(ElementFactory.classElement2("C", []))];
-    type27.typeArguments = typeArguments;
-    JUnitTestCase.assertEquals(typeArguments, type27.typeArguments);
+    type28.typeArguments = typeArguments;
+    JUnitTestCase.assertEquals(typeArguments, type28.typeArguments);
   }
   void test_substitute_equal() {
     ClassElementImpl classElement = new ClassElementImpl(ASTFactory.identifier2("A"));
     TypeVariableElementImpl parameterElement = new TypeVariableElementImpl(ASTFactory.identifier2("E"));
     InterfaceTypeImpl type = new InterfaceTypeImpl.con1(classElement);
     TypeVariableTypeImpl parameter = new TypeVariableTypeImpl(parameterElement);
     type.typeArguments = <Type2> [parameter];
     InterfaceTypeImpl argumentType = new InterfaceTypeImpl.con1(new ClassElementImpl(ASTFactory.identifier2("B")));
     InterfaceType result = type.substitute2(<Type2> [argumentType], <Type2> [parameter]);
     JUnitTestCase.assertEquals(classElement, result.element);
@@ skipping 314 matching lines @@
     return element;
   }
   static ClassElementImpl classElement2(String typeName, List<String> parameterNames) => classElement(typeName, object.type, parameterNames);
   static ConstructorElementImpl constructorElement(String name) => new ConstructorElementImpl(name == null ? null : ASTFactory.identifier2(name));
   static ExportElementImpl exportFor(LibraryElement exportedLibrary4, List<NamespaceCombinator> combinators4) {
     ExportElementImpl spec = new ExportElementImpl();
     spec.exportedLibrary = exportedLibrary4;
     spec.combinators = combinators4;
     return spec;
   }
-  static FieldElementImpl fieldElement(String name, bool isStatic, bool isFinal, bool isConst, Type2 type32) {
+  static FieldElementImpl fieldElement(String name, bool isStatic, bool isFinal, bool isConst, Type2 type33) {
     FieldElementImpl field = new FieldElementImpl.con1(ASTFactory.identifier2(name));
     field.const2 = isConst;
     field.final2 = isFinal;
     field.static = isStatic;
-    field.type = type32;
+    field.type = type33;
     PropertyAccessorElementImpl getter = new PropertyAccessorElementImpl.con2(field);
     getter.getter = true;
     getter.synthetic = true;
     field.getter = getter;
     FunctionTypeImpl getterType = new FunctionTypeImpl.con1(getter);
-    getterType.returnType = type32;
+    getterType.returnType = type33;
     getter.type = getterType;
     if (!isConst && !isFinal) {
       PropertyAccessorElementImpl setter = new PropertyAccessorElementImpl.con2(field);
       setter.setter = true;
       setter.synthetic = true;
       field.setter = setter;
       FunctionTypeImpl setterType = new FunctionTypeImpl.con1(getter);
-      setterType.normalParameterTypes = <Type2> [type32];
+      setterType.normalParameterTypes = <Type2> [type33];
       setterType.returnType = VoidTypeImpl.instance;
       setter.type = setterType;
     }
     return field;
   }
   static FunctionElementImpl functionElement(String functionName) => functionElement4(functionName, null, null, null, null);
   static FunctionElementImpl functionElement2(String functionName, ClassElement returnElement) => functionElement3(functionName, returnElement, null, null);
   static FunctionElementImpl functionElement3(String functionName, ClassElement returnElement, List<ClassElement> normalParameters, List<ClassElement> optionalParameters) {
     FunctionElementImpl functionElement = new FunctionElementImpl.con1(ASTFactory.identifier2(functionName));
     FunctionTypeImpl functionType = new FunctionTypeImpl.con1(functionElement);
@@ skipping 47 matching lines @@
   }
   static FunctionElementImpl functionElement5(String functionName, List<ClassElement> normalParameters) => functionElement3(functionName, null, normalParameters, null);
   static FunctionElementImpl functionElement6(String functionName, List<ClassElement> normalParameters, List<ClassElement> optionalParameters) => functionElement3(functionName, null, normalParameters, optionalParameters);
   static FunctionElementImpl functionElement7(String functionName, List<ClassElement> normalParameters, List<String> names, List<ClassElement> namedParameters) => functionElement4(functionName, null, normalParameters, names, namedParameters);
   static ClassElementImpl get object {
     if (_objectElement == null) {
       _objectElement = classElement("Object", (null as InterfaceType), []);
     }
     return _objectElement;
   }
-  static PropertyAccessorElementImpl getterElement(String name, bool isStatic, Type2 type33) {
+  static PropertyAccessorElementImpl getterElement(String name, bool isStatic, Type2 type34) {
     FieldElementImpl field = new FieldElementImpl.con1(ASTFactory.identifier2(name));
     field.static = isStatic;
     field.synthetic = true;
-    field.type = type33;
+    field.type = type34;
     PropertyAccessorElementImpl getter = new PropertyAccessorElementImpl.con2(field);
     getter.getter = true;
     field.getter = getter;
     FunctionTypeImpl getterType = new FunctionTypeImpl.con1(getter);
-    getterType.returnType = type33;
+    getterType.returnType = type34;
     getter.type = getterType;
     return getter;
   }
   static ImportElementImpl importFor(LibraryElement importedLibrary5, PrefixElement prefix13, List<NamespaceCombinator> combinators5) {
     ImportElementImpl spec = new ImportElementImpl();
     spec.importedLibrary = importedLibrary5;
     spec.prefix = prefix13;
     spec.combinators = combinators5;
     return spec;
   }
   static LibraryElementImpl library(AnalysisContext context, String libraryName) {
     String fileName = "${libraryName}.dart";
-    FileBasedSource source = new FileBasedSource.con1(null, FileUtilities2.createFile(fileName));
+    FileBasedSource source = new FileBasedSource.con1(context.sourceFactory, FileUtilities2.createFile(fileName));
     CompilationUnitElementImpl unit = new CompilationUnitElementImpl(fileName);
     unit.source = source;
     LibraryElementImpl library = new LibraryElementImpl(context, ASTFactory.libraryIdentifier2([libraryName]));
     library.definingCompilationUnit = unit;
     return library;
   }
   static LocalVariableElementImpl localVariableElement(Identifier name) => new LocalVariableElementImpl(name);
   static LocalVariableElementImpl localVariableElement2(String name) => new LocalVariableElementImpl(ASTFactory.identifier2(name));
   static MethodElementImpl methodElement(String methodName, Type2 returnType13, List<Type2> argumentTypes) {
     MethodElementImpl method = new MethodElementImpl.con1(ASTFactory.identifier2(methodName));
@@ skipping 21 matching lines @@
     ParameterElementImpl parameter = new ParameterElementImpl(ASTFactory.identifier2(name));
     parameter.parameterKind = ParameterKind.POSITIONAL;
     return parameter;
   }
   static PrefixElementImpl prefix(String name) => new PrefixElementImpl(ASTFactory.identifier2(name));
   static ParameterElementImpl requiredParameter(String name) {
     ParameterElementImpl parameter = new ParameterElementImpl(ASTFactory.identifier2(name));
     parameter.parameterKind = ParameterKind.REQUIRED;
     return parameter;
   }
-  static PropertyAccessorElementImpl setterElement(String name, bool isStatic, Type2 type34) {
+  static PropertyAccessorElementImpl setterElement(String name, bool isStatic, Type2 type35) {
     FieldElementImpl field = new FieldElementImpl.con1(ASTFactory.identifier2(name));
     field.static = isStatic;
     field.synthetic = true;
-    field.type = type34;
+    field.type = type35;
     PropertyAccessorElementImpl getter = new PropertyAccessorElementImpl.con2(field);
     getter.getter = true;
     field.getter = getter;
     FunctionTypeImpl getterType = new FunctionTypeImpl.con1(getter);
-    getterType.returnType = type34;
+    getterType.returnType = type35;
     getter.type = getterType;
     PropertyAccessorElementImpl setter = new PropertyAccessorElementImpl.con2(field);
     setter.setter = true;
     setter.synthetic = true;
     field.setter = setter;
     FunctionTypeImpl setterType = new FunctionTypeImpl.con1(getter);
-    setterType.normalParameterTypes = <Type2> [type34];
+    setterType.normalParameterTypes = <Type2> [type35];
     setterType.returnType = VoidTypeImpl.instance;
     setter.type = setterType;
     return setter;
   }
   static TopLevelVariableElementImpl topLevelVariableElement(Identifier name) => new TopLevelVariableElementImpl.con1(name);
   static TopLevelVariableElementImpl topLevelVariableElement2(String name) => new TopLevelVariableElementImpl.con2(name);
   /**
    * Prevent the creation of instances of this class.
    */
   ElementFactory() {
@@ skipping 255 matching lines @@
   void test_hashCode_element() {
     FunctionTypeImpl type = new FunctionTypeImpl.con1(new FunctionElementImpl.con1(ASTFactory.identifier2("f")));
     type.hashCode;
   }
   void test_hashCode_noElement() {
     FunctionTypeImpl type = new FunctionTypeImpl.con1((null as ExecutableElement));
     type.hashCode;
   }
   void test_isSubtypeOf_baseCase_classFunction() {
     ClassElementImpl functionElement = ElementFactory.classElement2("Function", []);
-    InterfaceTypeImpl functionType = new InterfaceTypeImpl_11(functionElement);
+    InterfaceTypeImpl functionType = new InterfaceTypeImpl_12(functionElement);
     FunctionType f = ElementFactory.functionElement("f").type;
     JUnitTestCase.assertTrue(f.isSubtypeOf(functionType));
   }
   void test_isSubtypeOf_baseCase_notFunctionType() {
     FunctionType f = ElementFactory.functionElement("f").type;
     InterfaceType t = ElementFactory.classElement2("C", []).type;
     JUnitTestCase.assertFalse(f.isSubtypeOf(t));
   }
   void test_isSubtypeOf_baseCase_null() {
     FunctionType f = ElementFactory.functionElement("f").type;
@@ skipping 391 matching lines @@
         final __test = new FunctionTypeImplTest();
         runJUnitTest(__test, __test.test_substitute2_equal);
       });
       _ut.test('test_substitute2_notEqual', () {
         final __test = new FunctionTypeImplTest();
         runJUnitTest(__test, __test.test_substitute2_notEqual);
       });
     });
   }
 }
-class InterfaceTypeImpl_11 extends InterfaceTypeImpl {
-  InterfaceTypeImpl_11(ClassElement arg0) : super.con1(arg0);
+class InterfaceTypeImpl_12 extends InterfaceTypeImpl {
+  InterfaceTypeImpl_12(ClassElement arg0) : super.con1(arg0);
   bool isDartCoreFunction() => true;
 }
 main() {
   FunctionTypeImplTest.dartSuite();
   InterfaceTypeImplTest.dartSuite();
   TypeVariableTypeImplTest.dartSuite();
   ClassElementImplTest.dartSuite();
   ElementLocationImplTest.dartSuite();
   ElementImplTest.dartSuite();
   LibraryElementImplTest.dartSuite();
 }