Rename analyzer-experimental to analyzer_experimental.

pkg/analyzer_experimental/test/generated/resolver_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.resolver_test;
 
 import 'dart:collection';
-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_junit.dart';
-import 'package:analyzer-experimental/src/generated/source_io.dart';
-import 'package:analyzer-experimental/src/generated/error.dart';
-import 'package:analyzer-experimental/src/generated/scanner.dart';
-import 'package:analyzer-experimental/src/generated/element.dart';
-import 'package:analyzer-experimental/src/generated/resolver.dart';
-import 'package:analyzer-experimental/src/generated/engine.dart';
-import 'package:analyzer-experimental/src/generated/java_engine_io.dart';
-import 'package:analyzer-experimental/src/generated/ast.dart' hide Annotation;
-import 'package:analyzer-experimental/src/generated/sdk.dart' show DartSdk;
+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_junit.dart';
+import 'package:analyzer_experimental/src/generated/source_io.dart';
+import 'package:analyzer_experimental/src/generated/error.dart';
+import 'package:analyzer_experimental/src/generated/scanner.dart';
+import 'package:analyzer_experimental/src/generated/element.dart';
+import 'package:analyzer_experimental/src/generated/resolver.dart';
+import 'package:analyzer_experimental/src/generated/engine.dart';
+import 'package:analyzer_experimental/src/generated/java_engine_io.dart';
+import 'package:analyzer_experimental/src/generated/ast.dart' hide Annotation;
+import 'package:analyzer_experimental/src/generated/sdk.dart' show DartSdk;
 import 'package:unittest/unittest.dart' as _ut;
 import 'test_support.dart';
 import 'ast_test.dart' show ASTFactory;
 import 'element_test.dart' show ElementFactory;
 
 class LibraryTest extends EngineTestCase {
   /**
    * The error listener to which all errors will be reported.
    */
   GatheringErrorListener _errorListener;
@@ skipping 879 matching lines @@
     verify([source]);
   }
   void fail_ambiguousImport_typeAnnotation() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["library L;", "import 'lib1.dart';", "import 'lib2.dart';", "class A extends N {}"]));
     addSource("/lib1.dart", EngineTestCase.createSource(["class N {}"]));
     addSource("/lib2.dart", EngineTestCase.createSource(["class N {}"]));
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.AMBIGUOUS_IMPORT]);
     verify([source]);
   }
-  void fail_caseExpressionTypeImplementsEquals() {
-    Source source = addSource("/test.dart", EngineTestCase.createSource(["class IntWrapper {", "  final int value;", "  const IntWrapper(this.value);", "  bool operator ==(IntWrapper x) {", "    return value == x.value;", "  }", "}", "", "f(IntWrapper a) {", "  switch(a) {", "    case(const IntWrapper(1)) : return 1;", "    default: return 0;", "  }", "}"]));
-    resolve(source, []);
-    assertErrors([CompileTimeErrorCode.CASE_EXPRESSION_TYPE_IMPLEMENTS_EQUALS]);
-    verify([source]);
-  }
   void fail_compileTimeConstantRaisesException() {
     Source source = addSource("/test.dart", EngineTestCase.createSource([]));
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.COMPILE_TIME_CONSTANT_RAISES_EXCEPTION]);
     verify([source]);
   }
   void fail_constEvalThrowsException() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["class C {", "  const C() { throw null; }", "}", "f() { return const C(); }"]));
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION]);
     verify([source]);
   }
-  void fail_constWithNonConst() {
-    Source source = addSource("/test.dart", EngineTestCase.createSource(["class T {", "  T(a, b, {c, d}) {};", "}", "f() { return const T(0, 1, c: 2, d: 3); }"]));
-    resolve(source, []);
-    assertErrors([CompileTimeErrorCode.CONST_WITH_NON_CONST]);
-    verify([source]);
-  }
   void fail_constWithNonConstantArgument() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["class T {", "  T(a) {};", "}", "f(p) { return const T(p); }"]));
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.CONST_WITH_NON_CONSTANT_ARGUMENT]);
     verify([source]);
   }
   void fail_constWithNonType() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["int A;", "f() {", "  return const A();", "}"]));
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.CONST_WITH_NON_TYPE]);
@@ skipping 368 matching lines @@
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE]);
     verify([source]);
   }
   void fail_nonConstantDefaultValue_positional() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["f([x = 2 + 3]) {}"]));
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE]);
     verify([source]);
   }
-  void fail_nonConstCaseExpression() {
-    Source source = addSource("/test.dart", EngineTestCase.createSource(["f(int p) {", "  switch (p) {", "    case 3 + 4:", "      break;", "  }", "}"]));
-    resolve(source, []);
-    assertErrors([CompileTimeErrorCode.NON_CONSTANT_CASE_EXPRESSION]);
-    verify([source]);
-  }
   void fail_nonConstMapAsExpressionStatement() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["f() {", "  {'a' : 0, 'b' : 1};", "}"]));
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.NON_CONST_MAP_AS_EXPRESSION_STATEMENT]);
     verify([source]);
   }
   void fail_nonConstMapKey() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["f(a) {", "  return const {a : 0};", "}"]));
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.NON_CONSTANT_MAP_KEY]);
@@ skipping 287 matching lines @@
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_NAME]);
     verify([source]);
   }
   void test_builtInIdentifierAsTypeVariableName() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["class A<as> {}"]));
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_VARIABLE_NAME]);
     verify([source]);
   }
+  void test_caseExpressionTypeImplementsEquals() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["class IntWrapper {", "  final int value;", "  const IntWrapper(this.value);", "  bool operator ==(IntWrapper x) {", "    return value == x.value;", "  }", "}", "", "f(IntWrapper a) {", "  switch(a) {", "    case(const IntWrapper(1)) : return 1;", "    default: return 0;", "  }", "}"]));
+    resolve(source, []);
+    assertErrors([CompileTimeErrorCode.CASE_EXPRESSION_TYPE_IMPLEMENTS_EQUALS]);
+    verify([source]);
+  }
   void test_compileTimeConstantRaisesExceptionDivideByZero() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["const int INF = 0 / 0;"]));
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.COMPILE_TIME_CONSTANT_RAISES_EXCEPTION_DIVIDE_BY_ZERO]);
     verify([source]);
   }
   void test_conflictingConstructorNameAndMember_field() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {", "  int x;", "  A.x() {}", "}"]));
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.CONFLICTING_CONSTRUCTOR_NAME_AND_FIELD]);
@@ skipping 28 matching lines @@
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE]);
     verify([source]);
   }
   void test_constWithInvalidTypeParameters() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {", "  const A() {}", "}", "f() { return const A<A>(); }"]));
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.CONST_WITH_INVALID_TYPE_PARAMETERS]);
     verify([source]);
   }
+  void test_constWithNonConst() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["class T {", "  T(a, b, {c, d}) {}", "}", "f() { return const T(0, 1, c: 2, d: 3); }"]));
+    resolve(source, []);
+    assertErrors([CompileTimeErrorCode.CONST_WITH_NON_CONST]);
+    verify([source]);
+  }
   void test_duplicateMemberError() {
     Source librarySource = addSource("/lib.dart", EngineTestCase.createSource(["library lib;", "", "part 'a.dart';", "part 'b.dart';"]));
     Source sourceA = addSource("/a.dart", EngineTestCase.createSource(["part of lib;", "", "class A {}"]));
     Source sourceB = addSource("/b.dart", EngineTestCase.createSource(["part of lib;", "", "class A {}"]));
     resolve(librarySource, [sourceA, sourceB]);
     assertErrors([CompileTimeErrorCode.DUPLICATE_DEFINITION]);
     verify([librarySource, sourceA, sourceB]);
   }
   void test_extendsNonClass() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["int A;", "class B extends A {}"]));
@@ skipping 21 matching lines @@
     Source source = addSource("/test.dart", EngineTestCase.createSource(["f() {", "  x: while (true) {", "    continue y;", "  }", "}"]));
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.LABEL_UNDEFINED]);
   }
   void test_newWithInvalidTypeParameters() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {}", "f() { return new A<A>(); }"]));
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.NEW_WITH_INVALID_TYPE_PARAMETERS]);
     verify([source]);
   }
+  void test_nonConstCaseExpression() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["f(int p, int q) {", "  switch (p) {", "    case 3 + q:", "      break;", "  }", "}"]));
+    resolve(source, []);
+    assertErrors([CompileTimeErrorCode.NON_CONSTANT_CASE_EXPRESSION]);
+    verify([source]);
+  }
   void test_nonConstListElement() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["f(a) {", "  return const [a];", "}"]));
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.NON_CONSTANT_LIST_ELEMENT]);
     verify([source]);
   }
   void test_nonConstMapValue() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["f(a) {", "  return const {'a' : a};", "}"]));
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.NON_CONSTANT_MAP_VALUE]);
@@ skipping 28 matching lines @@
         runJUnitTest(__test, __test.test_builtInIdentifierAsTypeVariableName);
       });
       _ut.test('test_builtInIdentifierAsTypedefName_classTypeAlias', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_builtInIdentifierAsTypedefName_classTypeAlias);
       });
       _ut.test('test_builtInIdentifierAsTypedefName_functionTypeAlias', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_builtInIdentifierAsTypedefName_functionTypeAlias);
       });
+      _ut.test('test_caseExpressionTypeImplementsEquals', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_caseExpressionTypeImplementsEquals);
+      });
       _ut.test('test_compileTimeConstantRaisesExceptionDivideByZero', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_compileTimeConstantRaisesExceptionDivideByZero);
       });
       _ut.test('test_conflictingConstructorNameAndMember_field', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_conflictingConstructorNameAndMember_field);
       });
       _ut.test('test_conflictingConstructorNameAndMember_method', () {
         final __test = new CompileTimeErrorCodeTest();
@@ skipping 12 matching lines @@
         runJUnitTest(__test, __test.test_constFormalParameter_simpleFormalParameter);
       });
       _ut.test('test_constInitializedWithNonConstValue', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_constInitializedWithNonConstValue);
       });
       _ut.test('test_constWithInvalidTypeParameters', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_constWithInvalidTypeParameters);
       });
+      _ut.test('test_constWithNonConst', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_constWithNonConst);
+      });
       _ut.test('test_duplicateMemberError', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_duplicateMemberError);
       });
       _ut.test('test_extendsNonClass', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_extendsNonClass);
       });
       _ut.test('test_implementsNonClass', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_implementsNonClass);
       });
       _ut.test('test_labelInOuterScope', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_labelInOuterScope);
       });
       _ut.test('test_labelUndefined_break', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_labelUndefined_break);
       });
       _ut.test('test_labelUndefined_continue', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_labelUndefined_continue);
       });
       _ut.test('test_newWithInvalidTypeParameters', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_newWithInvalidTypeParameters);
       });
+      _ut.test('test_nonConstCaseExpression', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_nonConstCaseExpression);
+      });
       _ut.test('test_nonConstListElement', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_nonConstListElement);
       });
       _ut.test('test_nonConstMapValue', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_nonConstMapValue);
       });
       _ut.test('test_uriWithInterpolation_constant', () {
         final __test = new CompileTimeErrorCodeTest();
@@ skipping 471 matching lines @@
   void test_visitSimpleIdentifier_lexicalScope_field_setter() {
     InterfaceType intType5 = _typeProvider.intType;
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String fieldName = "a";
     FieldElement field = ElementFactory.fieldElement(fieldName, false, false, false, intType5);
     classA.fields = <FieldElement> [field];
     classA.accessors = <PropertyAccessorElement> [field.getter, field.setter];
     SimpleIdentifier node = ASTFactory.identifier2(fieldName);
     ASTFactory.assignmentExpression(node, TokenType.EQ, ASTFactory.integer(0));
     resolveInClass(node, classA);
-    Element element47 = node.element;
-    EngineTestCase.assertInstanceOf(PropertyAccessorElement, element47);
-    JUnitTestCase.assertTrue(((element47 as PropertyAccessorElement)).isSetter());
+    Element element50 = node.element;
+    EngineTestCase.assertInstanceOf(PropertyAccessorElement, element50);
+    JUnitTestCase.assertTrue(((element50 as PropertyAccessorElement)).isSetter());
     _listener.assertNoErrors();
   }
   void test_visitSuperConstructorInvocation() {
     ClassElementImpl superclass = ElementFactory.classElement2("A", []);
     ConstructorElementImpl superConstructor = ElementFactory.constructorElement(null);
     superclass.constructors = <ConstructorElement> [superConstructor];
     ClassElementImpl subclass = ElementFactory.classElement("B", superclass.type, []);
     ConstructorElementImpl subConstructor = ElementFactory.constructorElement(null);
     subclass.constructors = <ConstructorElement> [subConstructor];
     SuperConstructorInvocation invocation = ASTFactory.superConstructorInvocation([]);
@@ skipping 558 matching lines @@
     assertErrors([StaticWarningCode.UNDEFINED_STATIC_METHOD_OR_GETTER]);
     verify([source]);
   }
   void fail_undefinedStaticMethodOrGetter_method() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["class C {}", "f(var p) {", "  f(C.m());", "}"]));
     resolve(source, []);
     assertErrors([StaticWarningCode.UNDEFINED_STATIC_METHOD_OR_GETTER]);
     verify([source]);
   }
   void test_constWithAbstractClass() {
-    Source source = addSource("/test.dart", EngineTestCase.createSource(["abstract class A {}", "void f() {", "  A a = const A();", "}"]));
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["abstract class A {", "  const A() {}", "}", "void f() {", "  A a = const A();", "}"]));
     resolve(source, []);
     assertErrors([StaticWarningCode.CONST_WITH_ABSTRACT_CLASS]);
     verify([source]);
   }
   void test_equalKeysInMap() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["var m = {'a' : 0, 'b' : 1, 'a' : 2};"]));
     resolve(source, []);
     assertErrors([StaticWarningCode.EQUAL_KEYS_IN_MAP]);
     verify([source]);
   }
@@ skipping 185 matching lines @@
     if (_intType == null) {
       initializeNumericTypes();
     }
     return _intType;
   }
   InterfaceType get listType {
     if (_listType == null) {
       ClassElementImpl listElement = ElementFactory.classElement2("List", ["E"]);
       _listType = listElement.type;
       Type2 eType = listElement.typeVariables[0].type;
+      listElement.accessors = <PropertyAccessorElement> [ElementFactory.getterElement("last", false, eType)];
       listElement.methods = <MethodElement> [ElementFactory.methodElement("[]", eType, [_intType]), ElementFactory.methodElement("[]=", VoidTypeImpl.instance, [_intType, eType])];
     }
     return _listType;
   }
   InterfaceType get mapType {
     if (_mapType == null) {
       _mapType = ElementFactory.classElement2("Map", ["K", "V"]).type;
     }
     return _mapType;
   }
@@ skipping 166 matching lines @@
   List<ASTNode> _unresolvedNodes = new List<ASTNode>();
   /**
    * A list containing all of the AST nodes that were resolved to an element of the wrong type.
    */
   List<ASTNode> _wrongTypedNodes = new List<ASTNode>();
   /**
    * Initialize a newly created verifier to verify that all of the nodes in the visited AST
    * structures that are expected to have been resolved have an element associated with them.
    */
   ResolutionVerifier() {
-    _jtd_constructor_306_impl();
+    _jtd_constructor_317_impl();
   }
-  _jtd_constructor_306_impl() {
-    _jtd_constructor_307_impl(null);
+  _jtd_constructor_317_impl() {
+    _jtd_constructor_318_impl(null);
   }
   /**
    * Initialize a newly created verifier to verify that all of the identifiers in the visited AST
    * structures that are expected to have been resolved have an element associated with them. Nodes
    * in the set of known exceptions are not expected to have been resolved, even if they normally
    * would have been expected to have been resolved.
    * @param knownExceptions a set containing nodes that are known to not be resolvable and should
    * therefore not cause the test to fail
    */
   ResolutionVerifier.con1(Set<ASTNode> knownExceptions2) {
-    _jtd_constructor_307_impl(knownExceptions2);
+    _jtd_constructor_318_impl(knownExceptions2);
   }
-  _jtd_constructor_307_impl(Set<ASTNode> knownExceptions2) {
+  _jtd_constructor_318_impl(Set<ASTNode> knownExceptions2) {
     this._knownExceptions = knownExceptions2;
   }
   /**
    * Assert that all of the visited identifiers were resolved.
    */
   void assertResolved() {
     if (!_unresolvedNodes.isEmpty || !_wrongTypedNodes.isEmpty) {
       PrintStringWriter writer = new PrintStringWriter();
       if (!_unresolvedNodes.isEmpty) {
         writer.print("Failed to resolve ");
@@ skipping 814 matching lines @@
     SimpleStringLiteral string = ASTFactory.string2(value);
     string.staticType = _typeProvider.stringType;
     return string;
   }
   /**
    * Return a simple identifier that has been resolved to a variable element with the given type.
    * @param type the type of the variable being represented
    * @param variableName the name of the variable
    * @return a simple identifier that has been resolved to a variable element with the given type
    */
-  SimpleIdentifier resolvedVariable(InterfaceType type36, String variableName) {
+  SimpleIdentifier resolvedVariable(InterfaceType type37, String variableName) {
     SimpleIdentifier identifier = ASTFactory.identifier2(variableName);
     VariableElementImpl element = ElementFactory.localVariableElement(identifier);
-    element.type = type36;
+    element.type = type37;
     identifier.element = element;
-    identifier.staticType = type36;
+    identifier.staticType = type37;
     return identifier;
   }
   /**
    * Set the type of the given parameter to the given type.
    * @param parameter the parameter whose type is to be set
    * @param type the new type of the given parameter
    */
-  void setType(FormalParameter parameter, Type2 type37) {
+  void setType(FormalParameter parameter, Type2 type38) {
     SimpleIdentifier identifier17 = parameter.identifier;
-    Element element48 = identifier17.element;
-    if (element48 is! ParameterElement) {
-      element48 = new ParameterElementImpl(identifier17);
-      identifier17.element = element48;
+    Element element51 = identifier17.element;
+    if (element51 is! ParameterElement) {
+      element51 = new ParameterElementImpl(identifier17);
+      identifier17.element = element51;
     }
-    ((element48 as ParameterElementImpl)).type = type37;
+    ((element51 as ParameterElementImpl)).type = type38;
   }
   static dartSuite() {
     _ut.group('StaticTypeAnalyzerTest', () {
       _ut.test('test_visitAdjacentStrings', () {
         final __test = new StaticTypeAnalyzerTest();
         runJUnitTest(__test, __test.test_visitAdjacentStrings);
       });
       _ut.test('test_visitArgumentDefinitionTest', () {
         final __test = new StaticTypeAnalyzerTest();
         runJUnitTest(__test, __test.test_visitArgumentDefinitionTest);
@@ skipping 304 matching lines @@
     EngineTestCase.assertLength(0, element.imports);
     JUnitTestCase.assertNull(element.library);
     EngineTestCase.assertLength(0, element.prefixes);
     EngineTestCase.assertLength(0, element.parts);
     CompilationUnitElement unit = element.definingCompilationUnit;
     JUnitTestCase.assertNotNull(unit);
     JUnitTestCase.assertEquals("lib.dart", unit.name);
     JUnitTestCase.assertEquals(element, unit.library);
     EngineTestCase.assertLength(0, unit.accessors);
     EngineTestCase.assertLength(0, unit.functions);
-    EngineTestCase.assertLength(0, unit.typeAliases);
+    EngineTestCase.assertLength(0, unit.functionTypeAliases);
     EngineTestCase.assertLength(0, unit.types);
     EngineTestCase.assertLength(0, unit.topLevelVariables);
   }
   void test_invalidUri_part() {
     Source librarySource = addSource("/lib.dart", EngineTestCase.createSource(["library lib;", "", "part '\${'a'}.dart';"]));
     LibraryElement element = buildLibrary(librarySource, [CompileTimeErrorCode.URI_WITH_INTERPOLATION]);
     JUnitTestCase.assertNotNull(element);
   }
   void test_missingLibraryDirectiveWithPart() {
     addSource("/a.dart", EngineTestCase.createSource(["part of lib;"]));
@@ skipping 193 matching lines @@
   AnalysisErrorListener _errorListener;
   ScopeTest_TestScope(LibraryElement definingLibrary, AnalysisErrorListener errorListener) {
     this._definingLibrary = definingLibrary;
     this._errorListener = errorListener;
   }
   LibraryElement get definingLibrary => _definingLibrary;
   AnalysisErrorListener get errorListener => _errorListener;
   Element lookup3(String name, LibraryElement referencingLibrary) => localLookup(name, referencingLibrary);
 }
 class SimpleResolverTest extends ResolverTestCase {
-  void fail_caseExpressionTypeImplementsEquals_Object() {
-    Source source = addSource("/test.dart", EngineTestCase.createSource(["class IntWrapper {", "  final int value;", "  const IntWrapper(this.value);", "}", "", "f(IntWrapper intWrapper) {", "  switch(intWrapper) {", "    case(const IntWrapper(1)) : return 1;", "    default: return 0;", "  }", "}"]));
-    resolve(source, []);
-    assertNoErrors();
-    verify([source]);
-  }
   void fail_staticInvocation() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {", "  static int get g => (a,b) => 0;", "}", "class B {", "  f() {", "    A.g(1,0);", "  }", "}"]));
     resolve(source, []);
     assertNoErrors();
     verify([source]);
   }
   void test_argumentDefinitionTestNonParameter_formalParameter() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["f(var v) {", "  return ?v;", "}"]));
     resolve(source, []);
     assertNoErrors();
@@ skipping 22 matching lines @@
     resolve(source, []);
     assertNoErrors();
     verify([source]);
   }
   void test_caseExpressionTypeImplementsEquals_int() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["f(int i) {", "  switch(i) {", "    case(1) : return 1;", "    default: return 0;", "  }", "}"]));
     resolve(source, []);
     assertNoErrors();
     verify([source]);
   }
+  void test_caseExpressionTypeImplementsEquals_Object() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["class IntWrapper {", "  final int value;", "  const IntWrapper(this.value);", "}", "", "f(IntWrapper intWrapper) {", "  switch(intWrapper) {", "    case(const IntWrapper(1)) : return 1;", "    default: return 0;", "  }", "}"]));
+    resolve(source, []);
+    assertNoErrors();
+    verify([source]);
+  }
   void test_caseExpressionTypeImplementsEquals_String() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["f(String s) {", "  switch(s) {", "    case('1') : return 1;", "    default: return 0;", "  }", "}"]));
     resolve(source, []);
     assertNoErrors();
     verify([source]);
   }
   void test_class_extends_implements() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["class A extends B implements C {}", "class B {}", "class C {}"]));
     resolve(source, []);
     assertNoErrors();
     verify([source]);
   }
   void test_constConstructorWithNonFinalField_const() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {", "  const int x;", "  const A() {}", "}"]));
     resolve(source, []);
     assertNoErrors();
     verify([source]);
   }
   void test_constConstructorWithNonFinalField_final() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {", "  final int x;", "  const A() {}", "}"]));
     resolve(source, []);
     assertNoErrors();
     verify([source]);
   }
+  void test_constConstructorWithNonFinalField_syntheticField() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {", "  const A();", "  set x(value) {}", "  get x {return 0;}", "}"]));
+    resolve(source, []);
+    assertNoErrors();
+    verify([source]);
+  }
   void test_duplicateDefinition_getter() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["bool get a => true;"]));
     resolve(source, []);
     assertNoErrors();
     verify([source]);
   }
   void test_empty() {
     Source source = addSource("/test.dart", "");
     resolve(source, []);
     assertNoErrors();
@@ skipping 46 matching lines @@
     resolve(source, []);
     assertNoErrors();
     verify([source]);
   }
   void test_invocationOfNonFunction_localVariable() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["f() {", "  var g;", "  g();", "}"]));
     resolve(source, []);
     assertNoErrors();
     verify([source]);
   }
+  void test_invoke_dynamicThroughGetter() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {", "  List get X => [() => 0];", "  m(A a) {", "    X.last();", "  }", "}"]));
+    resolve(source, []);
+    assertNoErrors();
+    verify([source]);
+  }
   void test_isValidMixin_badSuperclass() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["class A extends B {}", "class B {}"]));
     LibraryElement library = resolve(source, []);
     JUnitTestCase.assertNotNull(library);
     CompilationUnitElement unit = library.definingCompilationUnit;
     JUnitTestCase.assertNotNull(unit);
     List<ClassElement> classes = unit.types;
     EngineTestCase.assertLength(2, classes);
     JUnitTestCase.assertFalse(classes[0].isValidMixin());
     assertNoErrors();
@@ skipping 116 matching lines @@
         runJUnitTest(__test, __test.test_argumentDefinitionTestNonParameter_optionalParameter);
       });
       _ut.test('test_breakWithoutLabelInSwitch', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_breakWithoutLabelInSwitch);
       });
       _ut.test('test_builtInIdentifierAsType_dynamic', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_builtInIdentifierAsType_dynamic);
       });
+      _ut.test('test_caseExpressionTypeImplementsEquals_Object', () {
+        final __test = new SimpleResolverTest();
+        runJUnitTest(__test, __test.test_caseExpressionTypeImplementsEquals_Object);
+      });
       _ut.test('test_caseExpressionTypeImplementsEquals_String', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_caseExpressionTypeImplementsEquals_String);
       });
       _ut.test('test_caseExpressionTypeImplementsEquals_int', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_caseExpressionTypeImplementsEquals_int);
       });
       _ut.test('test_class_extends_implements', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_class_extends_implements);
       });
       _ut.test('test_constConstructorWithNonFinalField_const', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_constConstructorWithNonFinalField_const);
       });
       _ut.test('test_constConstructorWithNonFinalField_final', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_constConstructorWithNonFinalField_final);
       });
+      _ut.test('test_constConstructorWithNonFinalField_syntheticField', () {
+        final __test = new SimpleResolverTest();
+        runJUnitTest(__test, __test.test_constConstructorWithNonFinalField_syntheticField);
+      });
       _ut.test('test_duplicateDefinition_getter', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_duplicateDefinition_getter);
       });
       _ut.test('test_empty', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_empty);
       });
       _ut.test('test_forEachLoops_nonConflicting', () {
         final __test = new SimpleResolverTest();
@@ skipping 24 matching lines @@
         runJUnitTest(__test, __test.test_invocationOfNonFunction_dynamic);
       });
       _ut.test('test_invocationOfNonFunction_getter', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_invocationOfNonFunction_getter);
       });
       _ut.test('test_invocationOfNonFunction_localVariable', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_invocationOfNonFunction_localVariable);
       });
+      _ut.test('test_invoke_dynamicThroughGetter', () {
+        final __test = new SimpleResolverTest();
+        runJUnitTest(__test, __test.test_invoke_dynamicThroughGetter);
+      });
       _ut.test('test_isValidMixin_badSuperclass', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_isValidMixin_badSuperclass);
       });
       _ut.test('test_isValidMixin_constructor', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_isValidMixin_constructor);
       });
       _ut.test('test_isValidMixin_super', () {
         final __test = new SimpleResolverTest();
@@ skipping 44 matching lines @@
         runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_const);
       });
       _ut.test('test_typeArgumentNotMatchingBounds_new', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_new);
       });
     });
   }
 }
 main() {
-  /*ElementResolverTest.dartSuite();
-  LibraryElementBuilderTest.dartSuite();
-  LibraryTest.dartSuite();
-  StaticTypeAnalyzerTest.dartSuite();
-  TypeProviderImplTest.dartSuite();
-  TypeResolverVisitorTest.dartSuite();
-  EnclosedScopeTest.dartSuite();
-  LibraryImportScopeTest.dartSuite();
-  LibraryScopeTest.dartSuite();
-  ScopeTest.dartSuite();
-  CompileTimeErrorCodeTest.dartSuite();
-  ErrorResolverTest.dartSuite();
-  SimpleResolverTest.dartSuite();
-  StaticTypeWarningCodeTest.dartSuite();
-  StaticWarningCodeTest.dartSuite();*/
+//  ElementResolverTest.dartSuite();
+//  LibraryElementBuilderTest.dartSuite();
+//  LibraryTest.dartSuite();
+//  StaticTypeAnalyzerTest.dartSuite();
+//  TypeProviderImplTest.dartSuite();
+//  TypeResolverVisitorTest.dartSuite();
+//  EnclosedScopeTest.dartSuite();
+//  LibraryImportScopeTest.dartSuite();
+//  LibraryScopeTest.dartSuite();
+//  ScopeTest.dartSuite();
+//  CompileTimeErrorCodeTest.dartSuite();
+//  ErrorResolverTest.dartSuite();
+//  SimpleResolverTest.dartSuite();
+//  StaticTypeWarningCodeTest.dartSuite();
+//  StaticWarningCodeTest.dartSuite();
 }