Fix mixin resolution order when multiple mixins present.

pkg/analyzer/test/generated/resolver_test.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.resolver_test;
 
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/element_resolver.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/java_engine_io.dart';
 import 'package:analyzer/src/generated/java_io.dart';
 import 'package:analyzer/src/generated/parser.dart' show ParserErrorCode;
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/sdk.dart';
 import 'package:analyzer/src/generated/sdk_io.dart' show DirectoryBasedDartSdk;
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:analyzer/src/generated/static_type_analyzer.dart';
 import 'package:analyzer/src/generated/testing/ast_factory.dart';
+import 'package:analyzer/src/generated/testing/element_factory.dart';
 import 'package:analyzer/src/generated/testing/test_type_provider.dart';
-import 'package:analyzer/src/generated/testing/element_factory.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:unittest/unittest.dart';
 
 import '../reflective_tests.dart';
 import 'test_support.dart';
 
 
 main() {
   groupSep = ' | ';
   runReflectiveTests(AnalysisDeltaTest);
@@ skipping 4561 matching lines @@
         _inheritanceManager.getMapOfMembersInheritedFromClasses(classB);
     MemberMap mapA =
         _inheritanceManager.getMapOfMembersInheritedFromClasses(classA);
     expect(mapA.size, _numOfMembersInObject);
     expect(mapB.size, _numOfMembersInObject + 1);
     expect(mapB.get(methodName), same(methodM));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
+  void test_getMapOfMembersInheritedFromClasses_method_with_two_mixins() {
+    // class A1 { int m(); }
+    // class A2 { int m(); }
+    // class B extends Object with A1, A2 {}
+    ClassElementImpl classA1 = ElementFactory.classElement2("A1");
+    String methodName = "m";
+    MethodElement methodA1M =
+        ElementFactory.methodElement(methodName, _typeProvider.intType);
+    classA1.methods = <MethodElement>[methodA1M];
+    ClassElementImpl classA2 = ElementFactory.classElement2("A2");
+    MethodElement methodA2M =
+        ElementFactory.methodElement(methodName, _typeProvider.intType);
+    classA2.methods = <MethodElement>[methodA2M];
+    ClassElementImpl classB = ElementFactory.classElement2("B");
+    classB.mixins = <InterfaceType>[classA1.type, classA2.type];
+    MemberMap mapB =
+        _inheritanceManager.getMapOfMembersInheritedFromClasses(classB);
+    expect(mapB.get(methodName), same(methodA2M));
+    _assertNoErrors(classA1);
+    _assertNoErrors(classA2);
+    _assertNoErrors(classB);
+  }
+
   void test_getMapOfMembersInheritedFromInterfaces_accessor_extends() {
     // class A { int get g; }
     // class B extends A {}
     ClassElementImpl classA = ElementFactory.classElement2("A");
     String getterName = "g";
     PropertyAccessorElement getterG =
         ElementFactory.getterElement(getterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement>[getterG];
     ClassElementImpl classB = ElementFactory.classElement("B", classA.type);
     MemberMap mapB =
@@ skipping 1703 matching lines @@
     MemberMap map = new MemberMap();
     expect(map.size, 0);
     map.put(m1.name, m1);
     expect(map.size, 1);
     expect(map.get("m1"), m1);
   }
 }
 
 @reflectiveTest
 class NonHintCodeTest extends ResolverTestCase {
+  void fail_propagatedFieldType() {
+    // From dartbug.com/20019
+    Source source = addSource(r'''
+class A { }
+class X<T> {
+  final x = new List<T>();
+}
+class Z {
+  final X<A> y = new X<A>();
+  foo() {
+    y.x.add(new A());
+  }
+}''');
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
   void test_deadCode_deadBlock_conditionalElse_debugConst() {
     Source source = addSource(r'''
 const bool DEBUG = true;
 f() {
   DEBUG ? 1 : 2;
 }''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
@@ skipping 202 matching lines @@
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_importDeferredLibraryWithLoadFunction() {
     resolveWithErrors(<String>[r'''
 library lib1;
 f() {}''', r'''
 library root;
 import 'lib1.dart' deferred as lib1;
-main() { lib1.f(); }'''],
-          ErrorCode.EMPTY_LIST);
+main() { lib1.f(); }'''], ErrorCode.EMPTY_LIST);
   }
 
   void test_issue20904BuggyTypePromotionAtIfJoin_1() {
     // https://code.google.com/p/dart/issues/detail?id=20904
     Source source = addSource(r'''
 f(var message, var dynamic_) {
   if (message is Function) {
     message = dynamic_;
   }
   int s = message;
@@ skipping 182 matching lines @@
 }
 class B extends A {
   @override
   set m(int x) {}
 }''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
-  void fail_propagatedFieldType() {
-    // From dartbug.com/20019
-    Source source = addSource(r'''
-class A { }
-class X<T> {
-  final x = new List<T>();
-}
-class Z {
-  final X<A> y = new X<A>();
-  foo() {
-    y.x.add(new A());
-  }
-}''');
-    resolve(source);
-    assertNoErrors(source);
-    verify([source]);
-  }
-
   void test_proxy_annotation_prefixed() {
     Source source = addSource(r'''
 library L;
 @proxy
 class A {}
 f(var a) {
   a = new A();
   a.m();
   var x = a.g;
   a.s = 1;
@@ skipping 1087 matching lines @@
       CompilationUnit unit =
           resolveSource2("/lib${i + 1}.dart", sourceTexts[i]);
       // reference the source if this is the last source
       if (i + 1 == sourceTexts.length) {
         return unit.element.source;
       }
     }
     return null;
   }
 
-  void resolveWithErrors(List<String> strSources, List<ErrorCode> codes) {
-    // Analysis and assertions
-    Source source = resolveSources(strSources);
-    assertErrors(source, codes);
-    verify([source]);
-  }
-
   void resolveWithAndWithoutExperimental(List<String> strSources,
       List<ErrorCode> codesWithoutExperimental,
       List<ErrorCode> codesWithExperimental) {
     // Setup analysis context as non-experimental
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
 //    options.enableDeferredLoading = false;
     resetWithOptions(options);
     // Analysis and assertions
     Source source = resolveSources(strSources);
     assertErrors(source, codesWithoutExperimental);
     verify([source]);
     // Setup analysis context as experimental
     reset();
     // Analysis and assertions
     source = resolveSources(strSources);
     assertErrors(source, codesWithExperimental);
     verify([source]);
   }
 
+  void resolveWithErrors(List<String> strSources, List<ErrorCode> codes) {
+    // Analysis and assertions
+    Source source = resolveSources(strSources);
+    assertErrors(source, codes);
+    verify([source]);
+  }
+
   @override
   void setUp() {
     reset();
   }
 
   @override
   void tearDown() {
     analysisContext2 = null;
     super.tearDown();
   }
@@ skipping 110 matching lines @@
   ScopeTest_TestScope(this.errorListener);
 
   @override
   Element internalLookup(Identifier identifier, String name,
       LibraryElement referencingLibrary) =>
       localLookup(name, referencingLibrary);
 }
 
 @reflectiveTest
 class SimpleResolverTest extends ResolverTestCase {
+  void fail_getter_and_setter_fromMixins_property_access() {
+    // TODO(paulberry): it appears that auxiliaryElements isn't properly set on
+    // a SimpleIdentifier that's inside a property access.  This bug should be
+    // fixed.
+    Source source = addSource('''
+class B {}
+class M1 {
+  get x => null;
+  set x(value) {}
+}
+class M2 {
+  get x => null;
+  set x(value) {}
+}
+class C extends B with M1, M2 {}
+void main() {
+  new C().x += 1;
+}
+''');
+    LibraryElement library = resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+    // Verify that both the getter and setter for "x" in "new C().x" refer to
+    // the accessors defined in M2.
+    FunctionDeclaration main =
+        library.definingCompilationUnit.functions[0].node;
+    BlockFunctionBody body = main.functionExpression.body;
+    ExpressionStatement stmt = body.block.statements[0];
+    AssignmentExpression assignment = stmt.expression;
+    PropertyAccess propertyAccess = assignment.leftHandSide;
+    expect(
+        propertyAccess.propertyName.staticElement.enclosingElement.name,
+        'M2');
+    expect(
+        propertyAccess.propertyName.auxiliaryElements.staticElement.enclosingElement.name,
+        'M2');
+  }
+
   void fail_staticInvocation() {
     Source source = addSource(r'''
 class A {
   static int get g => (a,b) => 0;
 }
 class B {
   f() {
     A.g(1,0);
   }
 }''');
@@ skipping 678 matching lines @@
   P p;
   m(e) {
     if (p(e)) {}
   }
 }''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
+  void test_getter_and_setter_fromMixins_bare_identifier() {
+    Source source = addSource('''
+class B {}
+class M1 {
+  get x => null;
+  set x(value) {}
+}
+class M2 {
+  get x => null;
+  set x(value) {}
+}
+class C extends B with M1, M2 {
+  void f() {
+    x += 1;
+  }
+}
+''');
+    LibraryElement library = resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+    // Verify that both the getter and setter for "x" in C.f() refer to the
+    // accessors defined in M2.
+    ClassElement classC = library.definingCompilationUnit.types[3];
+    MethodDeclaration f = classC.getMethod('f').node;
+    BlockFunctionBody body = f.body;
+    ExpressionStatement stmt = body.block.statements[0];
+    AssignmentExpression assignment = stmt.expression;
+    SimpleIdentifier leftHandSide = assignment.leftHandSide;
+    expect(leftHandSide.staticElement.enclosingElement.name, 'M2');
+    expect(
+        leftHandSide.auxiliaryElements.staticElement.enclosingElement.name,
+        'M2');
+  }
+
+  void test_getter_fromMixins_bare_identifier() {
+    Source source = addSource('''
+class B {}
+class M1 {
+  get x => null;
+}
+class M2 {
+  get x => null;
+}
+class C extends B with M1, M2 {
+  f() {
+    return x;
+  }
+}
+''');
+    LibraryElement library = resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+    // Verify that the getter for "x" in C.f() refers to the getter defined in
+    // M2.
+    ClassElement classC = library.definingCompilationUnit.types[3];
+    MethodDeclaration f = classC.getMethod('f').node;
+    BlockFunctionBody body = f.body;
+    ReturnStatement stmt = body.block.statements[0];
+    SimpleIdentifier x = stmt.expression;
+    expect(x.staticElement.enclosingElement.name, 'M2');
+  }
+
+  void test_getter_fromMixins_property_access() {
+    Source source = addSource('''
+class B {}
+class M1 {
+  get x => null;
+}
+class M2 {
+  get x => null;
+}
+class C extends B with M1, M2 {}
+void main() {
+  var y = new C().x;
+}
+''');
+    LibraryElement library = resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+    // Verify that the getter for "x" in "new C().x" refers to the getter
+    // defined in M2.
+    FunctionDeclaration main =
+        library.definingCompilationUnit.functions[0].node;
+    BlockFunctionBody body = main.functionExpression.body;
+    VariableDeclarationStatement stmt = body.block.statements[0];
+    PropertyAccess propertyAccess = stmt.variables.variables[0].initializer;
+    expect(
+        propertyAccess.propertyName.staticElement.enclosingElement.name,
+        'M2');
+  }
+
   void test_getterAndSetterWithDifferentTypes() {
     Source source = addSource(r'''
 class A {
   int get f => 0;
   void set f(String s) {}
 }
 g (A a) {
   a.f = a.f.toString();
 }''');
     resolve(source);
@@ skipping 474 matching lines @@
 
 class C extends B with A {
   bar() => super.bar();
   foo() => super.foo();
 }''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
+  void test_method_fromMixins() {
+    Source source = addSource('''
+class B {}
+class M1 {
+  void f() {}
+}
+class M2 {
+  void f() {}
+}
+class C extends B with M1, M2 {}
+void main() {
+  new C().f();
+}
+''');
+    LibraryElement library = resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+    // Verify that the "f" in "new C().f()" refers to the "f" defined in M2.
+    FunctionDeclaration main =
+        library.definingCompilationUnit.functions[0].node;
+    BlockFunctionBody body = main.functionExpression.body;
+    ExpressionStatement stmt = body.block.statements[0];
+    MethodInvocation expr = stmt.expression;
+    expect(expr.methodName.staticElement.enclosingElement.name, 'M2');
+  }
+
+  void test_method_fromMixins_bare_identifier() {
+    Source source = addSource('''
+class B {}
+class M1 {
+  void f() {}
+}
+class M2 {
+  void f() {}
+}
+class C extends B with M1, M2 {
+  void g() {
+    f();
+  }
+}
+''');
+    LibraryElement library = resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+    // Verify that the call to f() in C.g() refers to the method defined in M2.
+    ClassElement classC = library.definingCompilationUnit.types[3];
+    MethodDeclaration g = classC.getMethod('g').node;
+    BlockFunctionBody body = g.body;
+    ExpressionStatement stmt = body.block.statements[0];
+    MethodInvocation invocation = stmt.expression;
+    SimpleIdentifier methodName = invocation.methodName;
+    expect(methodName.staticElement.enclosingElement.name, 'M2');
+  }
+
+  void test_method_fromMixins_invked_from_outside_class() {
+    Source source = addSource('''
+class B {}
+class M1 {
+  void f() {}
+}
+class M2 {
+  void f() {}
+}
+class C extends B with M1, M2 {}
+void main() {
+  new C().f();
+}
+''');
+    LibraryElement library = resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+    // Verify that the call to f() in "new C().f()" refers to the method
+    // defined in M2.
+    FunctionDeclaration main =
+        library.definingCompilationUnit.functions[0].node;
+    BlockFunctionBody body = main.functionExpression.body;
+    ExpressionStatement stmt = body.block.statements[0];
+    MethodInvocation invocation = stmt.expression;
+    expect(invocation.methodName.staticElement.enclosingElement.name, 'M2');
+  }
+
   void test_method_fromSuperclassMixin() {
     Source source = addSource(r'''
 class A {
   void m1() {}
 }
 class B extends Object with A {
 }
 class C extends B {
 }
 f(C c) {
@@ skipping 41 matching lines @@
 
   void test_resolveAgainstNull() {
     Source source = addSource(r'''
 f(var p) {
   return null == p;
 }''');
     resolve(source);
     assertNoErrors(source);
   }
 
+  void test_setter_fromMixins_bare_identifier() {
+    Source source = addSource('''
+class B {}
+class M1 {
+  set x(value) {}
+}
+class M2 {
+  set x(value) {}
+}
+class C extends B with M1, M2 {
+  void f() {
+    x = 1;
+  }
+}
+''');
+    LibraryElement library = resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+    // Verify that the setter for "x" in C.f() refers to the setter defined in
+    // M2.
+    ClassElement classC = library.definingCompilationUnit.types[3];
+    MethodDeclaration f = classC.getMethod('f').node;
+    BlockFunctionBody body = f.body;
+    ExpressionStatement stmt = body.block.statements[0];
+    AssignmentExpression assignment = stmt.expression;
+    SimpleIdentifier leftHandSide = assignment.leftHandSide;
+    expect(leftHandSide.staticElement.enclosingElement.name, 'M2');
+  }
+
+  void test_setter_fromMixins_property_access() {
+    Source source = addSource('''
+class B {}
+class M1 {
+  set x(value) {}
+}
+class M2 {
+  set x(value) {}
+}
+class C extends B with M1, M2 {}
+void main() {
+  new C().x = 1;
+}
+''');
+    LibraryElement library = resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+    // Verify that the setter for "x" in "new C().x" refers to the setter
+    // defined in M2.
+    FunctionDeclaration main =
+        library.definingCompilationUnit.functions[0].node;
+    BlockFunctionBody body = main.functionExpression.body;
+    ExpressionStatement stmt = body.block.statements[0];
+    AssignmentExpression assignment = stmt.expression;
+    PropertyAccess propertyAccess = assignment.leftHandSide;
+    expect(
+        propertyAccess.propertyName.staticElement.enclosingElement.name,
+        'M2');
+  }
+
   void test_setter_inherited() {
     Source source = addSource(r'''
 class A {
   int get x => 0;
   set x(int p) {}
 }
 class B extends A {
   int get x => super.x == null ? 0 : super.x;
   int f() => x = 1;
 }''');
@@ skipping 1882 matching lines @@
   }
 
   void test_getType_noScope() {
     TypeOverrideManager manager = new TypeOverrideManager();
     expect(manager.getType(ElementFactory.localVariableElement2("v")), isNull);
   }
 }
 
 @reflectiveTest
 class TypePropagationTest extends ResolverTestCase {
+  void fail_finalPropertyInducingVariable_classMember_instance() {
+    addNamedSource("/lib.dart", r'''
+class A {
+  final v = 0;
+}''');
+    String code = r'''
+import 'lib.dart';
+f(A a) {
+  return a.v; // marker
+}''';
+    _assertTypeOfMarkedExpression(
+        code,
+        typeProvider.dynamicType,
+        typeProvider.intType);
+  }
+
+  void fail_finalPropertyInducingVariable_classMember_instance_inherited() {
+    addNamedSource("/lib.dart", r'''
+class A {
+  final v = 0;
+}''');
+    String code = r'''
+import 'lib.dart';
+class B extends A {
+  m() {
+    return v; // marker
+  }
+}''';
+    _assertTypeOfMarkedExpression(
+        code,
+        typeProvider.dynamicType,
+        typeProvider.intType);
+  }
+
+  void
+      fail_finalPropertyInducingVariable_classMember_instance_propagatedTarget() {
+    addNamedSource("/lib.dart", r'''
+class A {
+  final v = 0;
+}''');
+    String code = r'''
+import 'lib.dart';
+f(p) {
+  if (p is A) {
+    return p.v; // marker
+  }
+}''';
+    _assertTypeOfMarkedExpression(
+        code,
+        typeProvider.dynamicType,
+        typeProvider.intType);
+  }
+
+  void fail_finalPropertyInducingVariable_classMember_static() {
+    addNamedSource("/lib.dart", r'''
+class A {
+  static final V = 0;
+}''');
+    String code = r'''
+import 'lib.dart';
+f() {
+  return A.V; // marker
+}''';
+    _assertTypeOfMarkedExpression(
+        code,
+        typeProvider.dynamicType,
+        typeProvider.intType);
+  }
+
+  void fail_finalPropertyInducingVariable_topLevelVaraible_prefixed() {
+    addNamedSource("/lib.dart", "final V = 0;");
+    String code = r'''
+import 'lib.dart' as p;
+f() {
+  var v2 = p.V; // marker prefixed
+}''';
+    _assertTypeOfMarkedExpression(
+        code,
+        typeProvider.dynamicType,
+        typeProvider.intType);
+  }
+
+  void fail_finalPropertyInducingVariable_topLevelVaraible_simple() {
+    addNamedSource("/lib.dart", "final V = 0;");
+    String code = r'''
+import 'lib.dart';
+f() {
+  return V; // marker simple
+}''';
+    _assertTypeOfMarkedExpression(
+        code,
+        typeProvider.dynamicType,
+        typeProvider.intType);
+  }
+
   void fail_mergePropagatedTypesAtJoinPoint_1() {
     // https://code.google.com/p/dart/issues/detail?id=19929
     _assertTypeOfMarkedExpression(r'''
 f1(x) {
   var y = [];
   if (x) {
     y = 0;
   } else {
     y = '';
   }
@@ skipping 266 matching lines @@
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     SimpleIdentifier identifier = EngineTestCase.findNode(
         unit,
         code,
         "context",
         (node) => node is SimpleIdentifier);
     expect(identifier.propagatedType.name, "CanvasRenderingContext2D");
   }
 
-  void fail_finalPropertyInducingVariable_classMember_instance() {
-    addNamedSource("/lib.dart", r'''
-class A {
-  final v = 0;
-}''');
-    String code = r'''
-import 'lib.dart';
-f(A a) {
-  return a.v; // marker
-}''';
-    _assertTypeOfMarkedExpression(
-        code,
-        typeProvider.dynamicType,
-        typeProvider.intType);
-  }
-
-  void fail_finalPropertyInducingVariable_classMember_instance_inherited() {
-    addNamedSource("/lib.dart", r'''
-class A {
-  final v = 0;
-}''');
-    String code = r'''
-import 'lib.dart';
-class B extends A {
-  m() {
-    return v; // marker
-  }
-}''';
-    _assertTypeOfMarkedExpression(
-        code,
-        typeProvider.dynamicType,
-        typeProvider.intType);
-  }
-
-  void
-      fail_finalPropertyInducingVariable_classMember_instance_propagatedTarget() {
-    addNamedSource("/lib.dart", r'''
-class A {
-  final v = 0;
-}''');
-    String code = r'''
-import 'lib.dart';
-f(p) {
-  if (p is A) {
-    return p.v; // marker
-  }
-}''';
-    _assertTypeOfMarkedExpression(
-        code,
-        typeProvider.dynamicType,
-        typeProvider.intType);
-  }
-
-  void fail_finalPropertyInducingVariable_classMember_static() {
-    addNamedSource("/lib.dart", r'''
-class A {
-  static final V = 0;
-}''');
-    String code = r'''
-import 'lib.dart';
-f() {
-  return A.V; // marker
-}''';
-    _assertTypeOfMarkedExpression(
-        code,
-        typeProvider.dynamicType,
-        typeProvider.intType);
-  }
-
-  void fail_finalPropertyInducingVariable_topLevelVaraible_prefixed() {
-    addNamedSource("/lib.dart", "final V = 0;");
-    String code = r'''
-import 'lib.dart' as p;
-f() {
-  var v2 = p.V; // marker prefixed
-}''';
-    _assertTypeOfMarkedExpression(
-        code,
-        typeProvider.dynamicType,
-        typeProvider.intType);
-  }
-
-  void fail_finalPropertyInducingVariable_topLevelVaraible_simple() {
-    addNamedSource("/lib.dart", "final V = 0;");
-    String code = r'''
-import 'lib.dart';
-f() {
-  return V; // marker simple
-}''';
-    _assertTypeOfMarkedExpression(
-        code,
-        typeProvider.dynamicType,
-        typeProvider.intType);
-  }
-
   void test_forEach() {
     String code = r'''
 main() {
   var list = <String> [];
   for (var e in list) {
     e;
   }
 }''';
     Source source = addSource(code);
     LibraryElement library = resolve(source);
@@ skipping 1759 matching lines @@
         // check propagated type
         FunctionType propagatedType = node.propagatedType as FunctionType;
         expect(propagatedType.returnType, test.typeProvider.stringType);
       } on AnalysisException catch (e, stackTrace) {
         thrownException[0] = new CaughtException(e, stackTrace);
       }
     }
     return null;
   }
 }