Add a flag to the element model to identify mixin applications.

pkg/analyzer/test/generated/all_the_rest_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.
 
 // 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.all_the_rest_test;
 
 import 'dart:collection';
@@ skipping 4799 matching lines @@
         Keyword.ABSTRACT, className, null, null, null, null);
     classDeclaration.accept(builder);
     List<ClassElement> types = holder.types;
     expect(types, hasLength(1));
     ClassElement type = types[0];
     expect(type, isNotNull);
     expect(type.name, className);
     List<TypeParameterElement> typeParameters = type.typeParameters;
     expect(typeParameters, hasLength(0));
     expect(type.isAbstract, isTrue);
+    expect(type.isMixinApplication, isFalse);
     expect(type.isSynthetic, isFalse);
   }
 
   void test_visitClassDeclaration_minimal() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String className = "C";
     ClassDeclaration classDeclaration =
         AstFactory.classDeclaration(null, className, null, null, null, null);
     classDeclaration.accept(builder);
     List<ClassElement> types = holder.types;
     expect(types, hasLength(1));
     ClassElement type = types[0];
     expect(type, isNotNull);
     expect(type.name, className);
     List<TypeParameterElement> typeParameters = type.typeParameters;
     expect(typeParameters, hasLength(0));
     expect(type.isAbstract, isFalse);
+    expect(type.isMixinApplication, isFalse);
     expect(type.isSynthetic, isFalse);
   }
 
   void test_visitClassDeclaration_parameterized() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String className = "C";
     String firstVariableName = "E";
     String secondVariableName = "F";
     ClassDeclaration classDeclaration = AstFactory.classDeclaration(null,
         className,
         AstFactory.typeParameterList([firstVariableName, secondVariableName]),
         null, null, null);
     classDeclaration.accept(builder);
     List<ClassElement> types = holder.types;
     expect(types, hasLength(1));
     ClassElement type = types[0];
     expect(type, isNotNull);
     expect(type.name, className);
     List<TypeParameterElement> typeParameters = type.typeParameters;
     expect(typeParameters, hasLength(2));
     expect(typeParameters[0].name, firstVariableName);
     expect(typeParameters[1].name, secondVariableName);
     expect(type.isAbstract, isFalse);
+    expect(type.isMixinApplication, isFalse);
     expect(type.isSynthetic, isFalse);
   }
 
   void test_visitClassDeclaration_withMembers() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String className = "C";
     String typeParameterName = "E";
     String fieldName = "f";
     String methodName = "m";
     ClassDeclaration classDeclaration = AstFactory.classDeclaration(null,
         className, AstFactory.typeParameterList([typeParameterName]), null,
         null, null, [
       AstFactory.fieldDeclaration2(
           false, null, [AstFactory.variableDeclaration(fieldName)]),
       AstFactory.methodDeclaration2(null, null, null, null,
           AstFactory.identifier3(methodName), AstFactory.formalParameterList(),
           AstFactory.blockFunctionBody2())
     ]);
     classDeclaration.accept(builder);
     List<ClassElement> types = holder.types;
     expect(types, hasLength(1));
     ClassElement type = types[0];
     expect(type, isNotNull);
     expect(type.name, className);
     expect(type.isAbstract, isFalse);
+    expect(type.isMixinApplication, isFalse);
     expect(type.isSynthetic, isFalse);
     List<TypeParameterElement> typeParameters = type.typeParameters;
     expect(typeParameters, hasLength(1));
     TypeParameterElement typeParameter = typeParameters[0];
     expect(typeParameter, isNotNull);
     expect(typeParameter.name, typeParameterName);
     List<FieldElement> fields = type.fields;
     expect(fields, hasLength(1));
     FieldElement field = fields[0];
     expect(field, isNotNull);
@@ skipping 21 matching lines @@
         AstFactory.withClause([AstFactory.typeName(classM, [])]);
     ClassTypeAlias alias = AstFactory.classTypeAlias(
         'C', null, null, AstFactory.typeName(classB, []), withClause, null);
     alias.accept(builder);
     List<ClassElement> types = holder.types;
     expect(types, hasLength(1));
     ClassElement type = types[0];
     expect(alias.element, same(type));
     expect(type.name, equals('C'));
     expect(type.isAbstract, isFalse);
+    expect(type.isMixinApplication, isTrue);
     expect(type.isSynthetic, isFalse);
     expect(type.typeParameters, isEmpty);
     expect(type.fields, isEmpty);
     expect(type.methods, isEmpty);
   }
 
   void test_visitClassTypeAlias_abstract() {
     // class B {}
     // class M {}
     // abstract class C = B with M
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     ClassElementImpl classB = ElementFactory.classElement2('B', []);
     ConstructorElementImpl constructorB =
         ElementFactory.constructorElement2(classB, '', []);
     constructorB.setModifier(Modifier.SYNTHETIC, true);
     classB.constructors = [constructorB];
     ClassElement classM = ElementFactory.classElement2('M', []);
     WithClause withClause =
         AstFactory.withClause([AstFactory.typeName(classM, [])]);
     ClassTypeAlias classCAst = AstFactory.classTypeAlias('C', null,
         Keyword.ABSTRACT, AstFactory.typeName(classB, []), withClause, null);
     classCAst.accept(builder);
     List<ClassElement> types = holder.types;
     expect(types, hasLength(1));
     ClassElement type = types[0];
     expect(type.isAbstract, isTrue);
+    expect(type.isMixinApplication, isTrue);
   }
 
   void test_visitClassTypeAlias_typeParams() {
     // class B {}
     // class M {}
     // class C<T> = B with M
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     ClassElementImpl classB = ElementFactory.classElement2('B', []);
     ConstructorElementImpl constructorB =
@@ skipping 3655 matching lines @@
     if (_expectedExternalScriptName == null) {
       expect(scriptSource, isNull, reason: "script $scriptIndex");
     } else {
       expect(scriptSource, isNotNull, reason: "script $scriptIndex");
       String actualExternalScriptName = scriptSource.shortName;
       expect(actualExternalScriptName, _expectedExternalScriptName,
           reason: "script $scriptIndex");
     }
   }
 }