diff --git a/pkg/analyzer/lib/dart/ast/ast.dart b/pkg/analyzer/lib/dart/ast/ast.dart
index 84c538a..777bdc3 100644
--- a/pkg/analyzer/lib/dart/ast/ast.dart
+++ b/pkg/analyzer/lib/dart/ast/ast.dart
@@ -5185,6 +5185,9 @@
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class MixinDeclaration extends NamedCompilationUnitMember {
+  @override
+  ClassElement get declaredElement;
+
   /**
    * Return the implements clause for the mixin, or `null` if the mixin does not
    * implement any interfaces.
diff --git a/pkg/analyzer/lib/src/dart/ast/ast.dart b/pkg/analyzer/lib/src/dart/ast/ast.dart
index c655ac4..573adfe 100644
--- a/pkg/analyzer/lib/src/dart/ast/ast.dart
+++ b/pkg/analyzer/lib/src/dart/ast/ast.dart
@@ -7816,8 +7816,7 @@
     ..add(rightBracket);
 
   @override
-//  MixinElement get declaredElement => _name?.staticElement as MixinElement;
-  Element get declaredElement => throw new UnimplementedError();
+  ClassElement get declaredElement => _name?.staticElement as ClassElement;
 
   @deprecated
   @override
diff --git a/pkg/analyzer/lib/src/generated/declaration_resolver.dart b/pkg/analyzer/lib/src/generated/declaration_resolver.dart
index e2ee324..4a24786 100644
--- a/pkg/analyzer/lib/src/generated/declaration_resolver.dart
+++ b/pkg/analyzer/lib/src/generated/declaration_resolver.dart
@@ -398,6 +398,16 @@
   }
 
   @override
+  Object visitMixinDeclaration(MixinDeclaration node) {
+    ClassElement element = _match(node.name, _walker.getMixin());
+    _walk(new ElementWalker.forClass(element), () {
+      super.visitMixinDeclaration(node);
+    });
+    resolveMetadata(node, node.metadata, element);
+    return null;
+  }
+
+  @override
   Object visitPartDirective(PartDirective node) {
     super.visitPartDirective(node);
     List<ElementAnnotation> annotations =
@@ -839,6 +849,8 @@
   int _enumIndex = 0;
   List<ExecutableElement> _functions;
   int _functionIndex = 0;
+  List<ClassElement> _mixins;
+  int _mixinIndex = 0;
   List<ParameterElement> _parameters;
   int _parameterIndex = 0;
   List<FunctionTypeAliasElement> _typedefs;
@@ -872,6 +884,7 @@
         _classes = compilationUnit.types,
         _enums = compilationUnit.enums,
         _functions = compilationUnit.functions,
+        _mixins = compilationUnit.mixins,
         _typedefs = compilationUnit.functionTypeAliases,
         _variables =
             compilationUnit.topLevelVariables.where(_isNotSynthetic).toList();
@@ -977,6 +990,12 @@
   ExecutableElement getFunction() => _functions[_functionIndex++];
 
   /**
+   * Returns the next non-synthetic child of [element] which is a mixin; throws
+   * an [IndexError] if there are no more.
+   */
+  ClassElement getMixin() => _mixins[_mixinIndex++];
+
+  /**
    * Returns the next non-synthetic child of [element] which is a parameter;
    * throws an [IndexError] if there are no more.
    */
diff --git a/pkg/analyzer/lib/src/generated/element_resolver.dart b/pkg/analyzer/lib/src/generated/element_resolver.dart
index d8b1349..974721e 100644
--- a/pkg/analyzer/lib/src/generated/element_resolver.dart
+++ b/pkg/analyzer/lib/src/generated/element_resolver.dart
@@ -716,6 +716,12 @@
   }
 
   @override
+  Object visitMixinDeclaration(MixinDeclaration node) {
+    resolveMetadata(node);
+    return null;
+  }
+
+  @override
   Object visitPartDirective(PartDirective node) {
     resolveMetadata(node);
     return null;
diff --git a/pkg/analyzer/lib/src/generated/parser_fasta.dart b/pkg/analyzer/lib/src/generated/parser_fasta.dart
index 43b0b5f..8cbdd21 100644
--- a/pkg/analyzer/lib/src/generated/parser_fasta.dart
+++ b/pkg/analyzer/lib/src/generated/parser_fasta.dart
@@ -27,6 +27,7 @@
       {bool allowNativeClause: false})
       : fastaParser = new fasta.Parser(null),
         astBuilder = new AstBuilder(errorReporter, fileUri, true) {
+    fastaParser.isMixinSupportEnabled = true;
     fastaParser.listener = astBuilder;
     astBuilder.parser = fastaParser;
     astBuilder.allowNativeClause = allowNativeClause;
diff --git a/pkg/analyzer/lib/src/generated/resolver.dart b/pkg/analyzer/lib/src/generated/resolver.dart
index bbe3d04..8329fb9 100644
--- a/pkg/analyzer/lib/src/generated/resolver.dart
+++ b/pkg/analyzer/lib/src/generated/resolver.dart
@@ -5025,6 +5025,12 @@
    */
   ExecutableElement _enclosingFunction = null;
 
+  /**
+   * The mixin declaration representing the class containing the current node,
+   * or `null` if the current node is not contained in a mixin.
+   */
+  MixinDeclaration _enclosingMixinDeclaration = null;
+
   InferenceContext inferenceContext = null;
 
   /**
@@ -5309,7 +5315,8 @@
   Object visitAnnotation(Annotation node) {
     AstNode parent = node.parent;
     if (identical(parent, _enclosingClassDeclaration) ||
-        identical(parent, _enclosingFunctionTypeAlias)) {
+        identical(parent, _enclosingFunctionTypeAlias) ||
+        identical(parent, _enclosingMixinDeclaration)) {
       return null;
     }
     node.name?.accept(this);
@@ -6211,6 +6218,31 @@
   }
 
   @override
+  Object visitMixinDeclaration(MixinDeclaration node) {
+    //
+    // Resolve the metadata in the library scope.
+    //
+    node.metadata?.accept(this);
+    _enclosingMixinDeclaration = node;
+    //
+    // Continue the class resolution.
+    //
+    ClassElement outerType = enclosingClass;
+    try {
+      enclosingClass = node.declaredElement;
+      typeAnalyzer.thisType = enclosingClass?.type;
+      super.visitMixinDeclaration(node);
+      node.accept(elementResolver);
+      node.accept(typeAnalyzer);
+    } finally {
+      typeAnalyzer.thisType = outerType?.type;
+      enclosingClass = outerType;
+      _enclosingMixinDeclaration = null;
+    }
+    return null;
+  }
+
+  @override
   Object visitNamedExpression(NamedExpression node) {
     InferenceContext.setTypeFromNode(node.expression, node);
     return super.visitNamedExpression(node);
@@ -7645,6 +7677,40 @@
     super.visitMethodDeclaration(node);
   }
 
+  @override
+  Object visitMixinDeclaration(MixinDeclaration node) {
+    ClassElement element = node.declaredElement;
+
+    Scope outerScope = nameScope;
+    ClassElement outerClass = enclosingClass;
+    try {
+      enclosingClass = element;
+
+      nameScope = new TypeParameterScope(nameScope, element);
+      visitMixinDeclarationInScope(node);
+
+      nameScope = new ClassScope(nameScope, element);
+      visitMixinMembersInScope(node);
+    } finally {
+      nameScope = outerScope;
+      enclosingClass = outerClass;
+    }
+    return null;
+  }
+
+  void visitMixinDeclarationInScope(MixinDeclaration node) {
+    node.name?.accept(this);
+    node.typeParameters?.accept(this);
+    node.onClause?.accept(this);
+    node.implementsClause?.accept(this);
+  }
+
+  void visitMixinMembersInScope(MixinDeclaration node) {
+    node.documentationComment?.accept(this);
+    node.metadata.accept(this);
+    node.members.accept(this);
+  }
+
   /**
    * Visit the given statement after it's scope has been created. This is used by ResolverVisitor to
    * correctly visit the 'then' and 'else' statements of an 'if' statement.
@@ -9694,7 +9760,8 @@
       }
       classElement.supertype = superclassType;
     }
-    _resolve(classElement, withClause, implementsClause);
+    _resolveWithClause(classElement, withClause);
+    _resolveImplementsClause(classElement, implementsClause);
     return null;
   }
 
@@ -9736,7 +9803,8 @@
     if (classElement != null) {
       classElement.supertype = superclassType;
     }
-    _resolve(classElement, node.withClause, node.implementsClause);
+    _resolveWithClause(classElement, node.withClause);
+    _resolveImplementsClause(classElement, node.implementsClause);
     return null;
   }
 
@@ -9915,6 +9983,15 @@
   }
 
   @override
+  void visitMixinDeclarationInScope(MixinDeclaration node) {
+    super.visitMixinDeclarationInScope(node);
+    MixinElementImpl element = node.declaredElement;
+    _resolveOnClause(element, node.onClause);
+    _resolveImplementsClause(element, node.implementsClause);
+    return null;
+  }
+
+  @override
   Object visitNode(AstNode node) {
     // In API mode we need to skip:
     //   - function bodies;
@@ -10180,24 +10257,10 @@
     return null;
   }
 
-  /**
-   * Resolve the types in the given [withClause] and [implementsClause] and
-   * associate those types with the given [classElement].
-   */
-  void _resolve(ClassElementImpl classElement, WithClause withClause,
-      ImplementsClause implementsClause) {
-    if (withClause != null) {
-      List<InterfaceType> mixinTypes = _resolveTypes(
-          withClause.mixinTypes,
-          CompileTimeErrorCode.MIXIN_OF_NON_CLASS,
-          CompileTimeErrorCode.MIXIN_OF_ENUM,
-          CompileTimeErrorCode.MIXIN_OF_NON_CLASS);
-      if (classElement != null) {
-        classElement.mixins = mixinTypes;
-      }
-    }
-    if (implementsClause != null) {
-      NodeList<TypeName> interfaces = implementsClause.interfaces;
+  void _resolveImplementsClause(
+      ClassElementImpl classElement, ImplementsClause clause) {
+    if (clause != null) {
+      NodeList<TypeName> interfaces = clause.interfaces;
       List<InterfaceType> interfaceTypes = _resolveTypes(
           interfaces,
           CompileTimeErrorCode.IMPLEMENTS_NON_CLASS,
@@ -10232,6 +10295,20 @@
     }
   }
 
+  void _resolveOnClause(MixinElementImpl classElement, OnClause clause) {
+    List<InterfaceType> types;
+    if (clause != null) {
+      types = _resolveTypes(
+          clause.superclassConstraints,
+          CompileTimeErrorCode.MIXIN_OF_NON_CLASS,
+          CompileTimeErrorCode.MIXIN_OF_ENUM,
+          CompileTimeErrorCode.MIXIN_OF_NON_CLASS);
+    } else {
+      types = [typeProvider.objectType];
+    }
+    classElement.superclassConstraints = types;
+  }
+
   /**
    * Return the type specified by the given name.
    *
@@ -10294,6 +10371,17 @@
     return types;
   }
 
+  void _resolveWithClause(ClassElementImpl classElement, WithClause clause) {
+    if (clause != null) {
+      List<InterfaceType> mixinTypes = _resolveTypes(
+          clause.mixinTypes,
+          CompileTimeErrorCode.MIXIN_OF_NON_CLASS,
+          CompileTimeErrorCode.MIXIN_OF_ENUM,
+          CompileTimeErrorCode.MIXIN_OF_NON_CLASS);
+      classElement.mixins = mixinTypes;
+    }
+  }
+
   /**
    * Given a function typed [parameter] with [FunctionType] based on a
    * [GenericFunctionTypeElementImpl], compute and set the return type for the
diff --git a/pkg/analyzer/lib/src/task/dart.dart b/pkg/analyzer/lib/src/task/dart.dart
index 5f96198..ee2ccc0 100644
--- a/pkg/analyzer/lib/src/task/dart.dart
+++ b/pkg/analyzer/lib/src/task/dart.dart
@@ -3761,8 +3761,6 @@
     parser.parseFunctionBodies =
         options.analyzeFunctionBodiesPredicate(_source);
     parser.enableOptionalNewAndConst = true;
-    (parser as ParserAdapter).fastaParser.isMixinSupportEnabled =
-        (options as AnalysisOptionsImpl).isMixinSupportEnabled;
     CompilationUnit unit = parser.parseCompilationUnit(tokenStream);
     unit.lineInfo = lineInfo;
 
diff --git a/pkg/analyzer/test/generated/hint_code_test.dart b/pkg/analyzer/test/generated/hint_code_test.dart
index 6619450..d0ab205 100644
--- a/pkg/analyzer/test/generated/hint_code_test.dart
+++ b/pkg/analyzer/test/generated/hint_code_test.dart
@@ -1660,7 +1660,6 @@
     verify([source]);
   }
 
-  @failingTest
   test_invalidSealedAnnotation_onMixin() async {
     Source source = addNamedSource('/lib1.dart', r'''
 import 'package:meta/meta.dart';
diff --git a/pkg/analyzer/test/src/dart/resolution/find_element.dart b/pkg/analyzer/test/src/dart/resolution/find_element.dart
index ce924b6..ff87f0e 100644
--- a/pkg/analyzer/test/src/dart/resolution/find_element.dart
+++ b/pkg/analyzer/test/src/dart/resolution/find_element.dart
@@ -1,5 +1,6 @@
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/dart/element/type.dart';
 import 'package:test/test.dart';
 
 import 'function_ast_visitor.dart';
@@ -85,6 +86,10 @@
     fail('Not found import: $targetUri');
   }
 
+  InterfaceType interfaceType(String name) {
+    return class_(name).type;
+  }
+
   LocalVariableElement localVar(String name) {
     LocalVariableElement result;
     unit.accept(new FunctionAstVisitor(
@@ -115,6 +120,15 @@
     fail('Not found class method: $name');
   }
 
+  ClassElement mixin(String name) {
+    for (var mixin in unitElement.mixins) {
+      if (mixin.name == name) {
+        return mixin;
+      }
+    }
+    fail('Not found mixin: $name');
+  }
+
   ParameterElement parameter(String name) {
     ParameterElement parameterElement;
     void considerParameter(ParameterElement parameter) {
diff --git a/pkg/analyzer/test/src/dart/resolution/find_node.dart b/pkg/analyzer/test/src/dart/resolution/find_node.dart
index ac80c6c..54b907a 100644
--- a/pkg/analyzer/test/src/dart/resolution/find_node.dart
+++ b/pkg/analyzer/test/src/dart/resolution/find_node.dart
@@ -12,116 +12,138 @@
     return unit.directives.singleWhere((d) => d is LibraryDirective);
   }
 
+  Annotation annotation(String search) {
+    return _node(search, (n) => n is Annotation);
+  }
+
   AssignmentExpression assignment(String search) {
-    return _node(search).getAncestor((n) => n is AssignmentExpression);
+    return _node(search, (n) => n is AssignmentExpression);
   }
 
   CascadeExpression cascade(String search) {
-    return _node(search).getAncestor((n) => n is CascadeExpression);
+    return _node(search, (n) => n is CascadeExpression);
+  }
+
+  CommentReference commentReference(String search) {
+    return _node(search, (n) => n is CommentReference);
   }
 
   ExportDirective export(String search) {
-    return _node(search).getAncestor((n) => n is ExportDirective);
+    return _node(search, (n) => n is ExportDirective);
   }
 
   FunctionExpression functionExpression(String search) {
-    return _node(search).getAncestor((n) => n is FunctionExpression);
+    return _node(search, (n) => n is FunctionExpression);
   }
 
   GenericFunctionType genericFunctionType(String search) {
-    return _node(search).getAncestor((n) => n is GenericFunctionType);
+    return _node(search, (n) => n is GenericFunctionType);
   }
 
   ImportDirective import(String search) {
-    return _node(search).getAncestor((n) => n is ImportDirective);
+    return _node(search, (n) => n is ImportDirective);
   }
 
   InstanceCreationExpression instanceCreation(String search) {
-    return _node(search).getAncestor((n) => n is InstanceCreationExpression);
+    return _node(search, (n) => n is InstanceCreationExpression);
   }
 
   ListLiteral listLiteral(String search) {
-    return _node(search).getAncestor((n) => n is ListLiteral);
+    return _node(search, (n) => n is ListLiteral);
   }
 
   MapLiteral mapLiteral(String search) {
-    return _node(search).getAncestor((n) => n is MapLiteral);
+    return _node(search, (n) => n is MapLiteral);
+  }
+
+  MethodDeclaration methodDeclaration(String search) {
+    return _node(search, (n) => n is MethodDeclaration);
   }
 
   MethodInvocation methodInvocation(String search) {
-    return _node(search).getAncestor((n) => n is MethodInvocation);
+    return _node(search, (n) => n is MethodInvocation);
+  }
+
+  MixinDeclaration mixin(String search) {
+    return _node(search, (n) => n is MixinDeclaration);
   }
 
   ParenthesizedExpression parenthesized(String search) {
-    return _node(search).getAncestor((n) => n is ParenthesizedExpression);
+    return _node(search, (n) => n is ParenthesizedExpression);
   }
 
   PartDirective part(String search) {
-    return _node(search).getAncestor((n) => n is PartDirective);
+    return _node(search, (n) => n is PartDirective);
   }
 
   PartOfDirective partOf(String search) {
-    return _node(search).getAncestor((n) => n is PartOfDirective);
+    return _node(search, (n) => n is PartOfDirective);
   }
 
   PostfixExpression postfix(String search) {
-    return _node(search).getAncestor((n) => n is PostfixExpression);
+    return _node(search, (n) => n is PostfixExpression);
   }
 
   PrefixExpression prefix(String search) {
-    return _node(search).getAncestor((n) => n is PrefixExpression);
+    return _node(search, (n) => n is PrefixExpression);
   }
 
   PrefixedIdentifier prefixed(String search) {
-    return _node(search).getAncestor((n) => n is PrefixedIdentifier);
+    return _node(search, (n) => n is PrefixedIdentifier);
   }
 
   RethrowExpression rethrow_(String search) {
-    return _node(search).getAncestor((n) => n is RethrowExpression);
+    return _node(search, (n) => n is RethrowExpression);
   }
 
   SimpleIdentifier simple(String search) {
-    return _node(search);
+    return _node(search, (_) => true);
   }
 
   SimpleFormalParameter simpleParameter(String search) {
-    return _node(search).getAncestor((n) => n is SimpleFormalParameter);
+    return _node(search, (n) => n is SimpleFormalParameter);
   }
 
   StringLiteral stringLiteral(String search) {
-    return _node(search).getAncestor((n) => n is StringLiteral);
+    return _node(search, (n) => n is StringLiteral);
   }
 
   SuperExpression super_(String search) {
-    return _node(search).getAncestor((n) => n is SuperExpression);
+    return _node(search, (n) => n is SuperExpression);
   }
 
   ThisExpression this_(String search) {
-    return _node(search).getAncestor((n) => n is ThisExpression);
+    return _node(search, (n) => n is ThisExpression);
   }
 
   ThrowExpression throw_(String search) {
-    return _node(search).getAncestor((n) => n is ThrowExpression);
+    return _node(search, (n) => n is ThrowExpression);
   }
 
   TypeName typeName(String search) {
-    return _node(search).getAncestor((n) => n is TypeName);
+    return _node(search, (n) => n is TypeName);
   }
 
   TypeParameter typeParameter(String search) {
-    return _node(search).getAncestor((n) => n is TypeParameter);
+    return _node(search, (n) => n is TypeParameter);
   }
 
   VariableDeclaration variableDeclaration(String search) {
-    return _node(search).getAncestor((n) => n is VariableDeclaration);
+    return _node(search, (n) => n is VariableDeclaration);
   }
 
-  AstNode _node(String search) {
+  AstNode _node(String search, bool Function(AstNode) predicate) {
     var index = content.indexOf(search);
     if (content.indexOf(search, index + 1) != -1) {
       fail('The pattern |$search| is not unique in:\n$content');
     }
     expect(index, greaterThanOrEqualTo(0));
-    return new NodeLocator2(index).searchWithin(unit);
+
+    var node = new NodeLocator2(index).searchWithin(unit);
+    expect(node, isNotNull);
+
+    var result = node.getAncestor(predicate);
+    expect(result, isNotNull);
+    return result;
   }
 }
diff --git a/pkg/analyzer/test/src/dart/resolution/mixin_test.dart b/pkg/analyzer/test/src/dart/resolution/mixin_test.dart
new file mode 100644
index 0000000..205c71f
--- /dev/null
+++ b/pkg/analyzer/test/src/dart/resolution/mixin_test.dart
@@ -0,0 +1,222 @@
+import 'package:test/test.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import 'driver_resolution.dart';
+import 'resolution.dart';
+import 'task_resolution.dart';
+
+main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(MixinDriverResolutionTest);
+    defineReflectiveTests(MixinTaskResolutionTest);
+  });
+}
+
+abstract class AssignmentResolutionMixin implements ResolutionTest {
+  test_accessor_getter() async {
+    addTestFile(r'''
+mixin M {
+  int get g => 0;
+}
+''');
+    await resolveTestFile();
+
+    var element = findElement.mixin('M');
+
+    var accessors = element.accessors;
+    expect(accessors, hasLength(1));
+
+    var gElement = accessors[0];
+    assertElementName(gElement, 'g', offset: 20);
+
+    var gNode = findNode.methodDeclaration('g =>');
+    assertElement(gNode.name, gElement);
+
+    var fields = element.fields;
+    expect(fields, hasLength(1));
+    assertElementName(fields[0], 'g', isSynthetic: true);
+  }
+
+  test_accessor_method() async {
+    addTestFile(r'''
+mixin M {
+  void foo() {}
+}
+''');
+    await resolveTestFile();
+
+    var element = findElement.mixin('M');
+
+    var methods = element.methods;
+    expect(methods, hasLength(1));
+
+    var fooElement = methods[0];
+    assertElementName(fooElement, 'foo', offset: 17);
+
+    var fooNode = findNode.methodDeclaration('foo()');
+    assertElement(fooNode.name, fooElement);
+  }
+
+  test_accessor_setter() async {
+    addTestFile(r'''
+mixin M {
+  void set s(int _) {}
+}
+''');
+    await resolveTestFile();
+
+    var element = findElement.mixin('M');
+
+    var accessors = element.accessors;
+    expect(accessors, hasLength(1));
+
+    var sElement = accessors[0];
+    assertElementName(sElement, 's=', offset: 21);
+
+    var gNode = findNode.methodDeclaration('s(int _)');
+    assertElement(gNode.name, sElement);
+
+    var fields = element.fields;
+    expect(fields, hasLength(1));
+    assertElementName(fields[0], 's', isSynthetic: true);
+  }
+
+  test_commentReference() async {
+    addTestFile(r'''
+const a = 0;
+
+/// Reference [a] in documentation.
+mixin M {}
+''');
+    await resolveTestFile();
+
+    var aRef = findNode.commentReference('a]').identifier;
+    assertElement(aRef, findElement.topGet('a'));
+    assertTypeNull(aRef);
+  }
+
+  test_element() async {
+    addTestFile(r'''
+mixin M {}
+''');
+    await resolveTestFile();
+
+    var mixin = findNode.mixin('mixin M');
+    var element = findElement.mixin('M');
+    assertElement(mixin, element);
+
+    expect(element.typeParameters, isEmpty);
+    assertElementTypes(element.superclassConstraints, [objectType]);
+  }
+
+  test_field() async {
+    addTestFile(r'''
+mixin M<T> {
+  T f;
+}
+''');
+    await resolveTestFile();
+
+    var element = findElement.mixin('M');
+
+    var typeParameters = element.typeParameters;
+    expect(typeParameters, hasLength(1));
+
+    var tElement = typeParameters.single;
+    assertElementName(tElement, 'T', offset: 8);
+    assertEnclosingElement(tElement, element);
+
+    var tNode = findNode.typeParameter('T> {');
+    assertElement(tNode.name, tElement);
+
+    var fields = element.fields;
+    expect(fields, hasLength(1));
+
+    var fElement = fields[0];
+    assertElementName(fElement, 'f', offset: 17);
+    assertEnclosingElement(fElement, element);
+
+    var fNode = findNode.variableDeclaration('f;');
+    assertElement(fNode.name, fElement);
+
+    assertTypeName(findNode.typeName('T f'), tElement, 'T');
+
+    var accessors = element.accessors;
+    expect(accessors, hasLength(2));
+    assertElementName(accessors[0], 'f', isSynthetic: true);
+    assertElementName(accessors[1], 'f=', isSynthetic: true);
+  }
+
+  test_implementsClause() async {
+    addTestFile(r'''
+class A {}
+class B {}
+
+mixin M implements A, B {} // M
+''');
+    await resolveTestFile();
+
+    var element = findElement.mixin('M');
+    assertElementTypes(element.interfaces, [
+      findElement.interfaceType('A'),
+      findElement.interfaceType('B'),
+    ]);
+
+    var aRef = findNode.typeName('A, ');
+    assertTypeName(aRef, findElement.class_('A'), 'A');
+
+    var bRef = findNode.typeName('B {} // M');
+    assertTypeName(bRef, findElement.class_('B'), 'B');
+  }
+
+  test_metadata() async {
+    addTestFile(r'''
+const a = 0;
+
+@a
+mixin M {}
+''');
+    await resolveTestFile();
+
+    var a = findElement.topGet('a');
+    var element = findElement.mixin('M');
+
+    var metadata = element.metadata;
+    expect(metadata, hasLength(1));
+    expect(metadata[0].element, same(a));
+
+    var annotation = findNode.annotation('@a');
+    assertElement(annotation, a);
+    expect(annotation.elementAnnotation, same(metadata[0]));
+  }
+
+  test_onClause() async {
+    addTestFile(r'''
+class A {}
+class B {}
+
+mixin M on A, B {} // M
+''');
+    await resolveTestFile();
+
+    var element = findElement.mixin('M');
+    assertElementTypes(element.superclassConstraints, [
+      findElement.interfaceType('A'),
+      findElement.interfaceType('B'),
+    ]);
+
+    var aRef = findNode.typeName('A, ');
+    assertTypeName(aRef, findElement.class_('A'), 'A');
+
+    var bRef = findNode.typeName('B {} // M');
+    assertTypeName(bRef, findElement.class_('B'), 'B');
+  }
+}
+
+@reflectiveTest
+class MixinDriverResolutionTest extends DriverResolutionTest
+    with AssignmentResolutionMixin {}
+
+@reflectiveTest
+class MixinTaskResolutionTest extends TaskResolutionTest
+    with AssignmentResolutionMixin {}
diff --git a/pkg/analyzer/test/src/dart/resolution/resolution.dart b/pkg/analyzer/test/src/dart/resolution/resolution.dart
index 9533052..b93718a 100644
--- a/pkg/analyzer/test/src/dart/resolution/resolution.dart
+++ b/pkg/analyzer/test/src/dart/resolution/resolution.dart
@@ -41,6 +41,8 @@
 
   ClassElement get numElement => typeProvider.numType.element;
 
+  InterfaceType get objectType => typeProvider.objectType;
+
   TypeProvider get typeProvider =>
       result.unit.declaredElement.context.typeProvider;
 
@@ -53,11 +55,35 @@
     expect(actual, same(expected));
   }
 
+  void assertElementName(Element element, String name,
+      {bool isSynthetic = false, int offset}) {
+    expect(element.name, name);
+    expect(element.isSynthetic, isSynthetic);
+    if (offset != null) {
+      expect(element.nameOffset, offset);
+    }
+  }
+
   void assertElementNull(Expression node) {
     Element actual = getNodeElement(node);
     expect(actual, isNull);
   }
 
+  void assertElementType(DartType type, DartType expected) {
+    expect(type, expected);
+  }
+
+  void assertElementTypes(List<DartType> types, List<DartType> expected) {
+    expect(types, hasLength(expected.length));
+    for (var i = 0; i < types.length; ++i) {
+      assertElementType(types[i], expected[i]);
+    }
+  }
+
+  void assertEnclosingElement(Element element, Element expectedEnclosing) {
+    expect(element.enclosingElement, expectedEnclosing);
+  }
+
   void assertIdentifierTopGetRef(SimpleIdentifier ref, String name) {
     var getter = findElement.topGet(name);
     assertElement(ref, getter);
@@ -129,9 +155,13 @@
     expect(node.staticType, isNull);
   }
 
-  Element getNodeElement(Expression node) {
-    if (node is AssignmentExpression) {
+  Element getNodeElement(AstNode node) {
+    if (node is Annotation) {
+      return node.element;
+    } else if (node is AssignmentExpression) {
       return node.staticElement;
+    } else if (node is Declaration) {
+      return node.declaredElement;
     } else if (node is Identifier) {
       return node.staticElement;
     } else if (node is IndexExpression) {