Add AstBuilder support for class declarations and named mixin applications.

pkg/front_end/lib/src/fasta/analyzer/ast_builder.dart

 // Copyright (c) 2016, 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 fasta.analyzer.ast_builder;
 
 import 'package:front_end/src/fasta/scanner/token.dart'
     show BeginGroupToken, Token;
 
 import 'package:analyzer/analyzer.dart';
@@ skipping 711 matching lines @@
     List<SimpleIdentifier> shownNames = pop();
     push(ast.showCombinator(toAnalyzerToken(showKeyword), shownNames));
   }
 
   @override
   void endHide(Token hideKeyword) {
     debugEvent("Hide");
     List<SimpleIdentifier> hiddenNames = pop();
     push(ast.hideCombinator(toAnalyzerToken(hideKeyword), hiddenNames));
   }
+
+  @override
+  void endTypeList(int count) {
+    debugEvent("TypeList");
+    push(popList(count) ?? NullValue.TypeList);
+  }
+
+  @override
+  void endClassBody(int memberCount, Token beginToken, Token endToken) {
+    debugEvent("ClassBody");
+    push(new _ClassBody(
+        beginToken, popList(memberCount) ?? <ClassMember>[], endToken));
+  }
+
+  @override
+  void endClassDeclaration(int interfacesCount, Token beginToken,
+      Token extendsKeyword, Token implementsKeyword, Token endToken) {
+    debugEvent("ClassDeclaration");
+    _ClassBody body = pop();
+    ImplementsClause implementsClause;
+    if (implementsKeyword != null) {
+      List<TypeName> interfaces = popList(interfacesCount);
+      implementsClause =
+          ast.implementsClause(toAnalyzerToken(implementsKeyword), interfaces);
+    }
+    ExtendsClause extendsClause;
+    WithClause withClause;
+    var supertype = pop();
+    if (supertype == null) {
+      // No extends clause
+    } else if (supertype is TypeName) {
+      extendsClause =
+          ast.extendsClause(toAnalyzerToken(extendsKeyword), supertype);
+    } else if (supertype is _MixinApplication) {
+      extendsClause = ast.extendsClause(
+          toAnalyzerToken(extendsKeyword), supertype.supertype);
+      withClause = ast.withClause(
+          toAnalyzerToken(supertype.withKeyword), supertype.mixinTypes);
+    } else {
+      internalError('Unexpected kind of supertype ${supertype.runtimeType}');
+    }
+    TypeParameterList typeParameters = pop();
+    SimpleIdentifier name = pop();
+    Token classKeyword;
+    // TODO(paulberry,ahe): This is a hack.  The parser should give us the class
+    // keyword.

[ahe, 2017/02/20 13:04:39]

No problem. If you file bugs with lack of token information in parser events,
I'll fix them.

When I change the signature of an event, I have to modify dart2js as well, so it
takes a little longer to run tests. This is why I prefer having a bug and take
them in batches.

[Paul Berry, 2017/02/20 14:25:10]

Ok.  I'm still planning to go through all my CLs collecting issues to file; when
I do that I'll make sure to capture issues like this.  I'll try to get to that
tomorrow at the latest.

+    if (identical(beginToken.value, 'abstract')) {

[ahe, 2017/02/20 13:04:39]

I suggest using optional like this:

if (optional("abstract", token)) {
...
}

This method is exported by ../parser/parser.dart

[Paul Berry, 2017/02/20 14:25:10]

Acknowledged.

+      classKeyword = beginToken.next;
+    } else {
+      classKeyword = beginToken;
+    }
+    var modifiers = pop();
+    assert(modifiers == null); // TODO(paulberry)
+    analyzer.Token abstractKeyword;
+    List<Annotation> metadata = pop();
+    Comment comment = null; // TODO(paulberry)
+    push(ast.classDeclaration(
+        comment,
+        metadata,
+        abstractKeyword,
+        toAnalyzerToken(classKeyword),
+        name,
+        typeParameters,
+        extendsClause,
+        withClause,
+        implementsClause,
+        toAnalyzerToken(body.beginToken),
+        body.members,
+        toAnalyzerToken(body.endToken)));
+  }
+
+  @override
+  void endMixinApplication() {
+    debugEvent("MixinApplication");
+    List<TypeName> mixinTypes = pop();
+    // TODO(paulberry,ahe): the parser doesn't give us enough information to
+    // locate the "with" keyword.
+    Token withKeyword;
+    TypeName supertype = pop();
+    push(new _MixinApplication(supertype, withKeyword, mixinTypes));
+  }
+
+  @override
+  void endNamedMixinApplication(
+      Token beginToken, Token implementsKeyword, Token endToken) {
+    debugEvent("NamedMixinApplication");
+    ImplementsClause implementsClause;
+    if (implementsKeyword != null) {
+      List<TypeName> interfaces = pop();
+      implementsClause =
+          ast.implementsClause(toAnalyzerToken(implementsKeyword), interfaces);
+    }
+    _MixinApplication mixinApplication = pop();
+    var superclass = mixinApplication.supertype;
+    var withClause = ast.withClause(
+        toAnalyzerToken(mixinApplication.withKeyword),
+        mixinApplication.mixinTypes);
+    // TODO(paulberry,ahe): the parser should give us the "=" token.
+    analyzer.Token equals;
+    TypeParameterList typeParameters = pop();
+    SimpleIdentifier name = pop();
+    Token classKeyword;
+    // TODO(paulberry,ahe): This is a hack.  The parser should give us the class
+    // keyword.

[ahe, 2017/02/20 13:04:39]

I agree with all these comments about the parser giving access to tokens.

+    if (identical(beginToken.value, 'abstract')) {
+      classKeyword = beginToken.next;
+    } else {
+      classKeyword = beginToken;
+    }
+    var modifiers = pop();
+    assert(modifiers == null); // TODO(paulberry)
+    analyzer.Token abstractKeyword;
+    List<Annotation> metadata = pop();
+    Comment comment = null; // TODO(paulberry)
+    push(ast.classTypeAlias(
+        comment,
+        metadata,
+        toAnalyzerToken(classKeyword),
+        name,
+        typeParameters,
+        equals,
+        abstractKeyword,
+        superclass,
+        withClause,
+        implementsClause,
+        toAnalyzerToken(endToken)));
+  }
 }
+
+/// Data structure placed on the stack to represent a class body.
+///
+/// This is needed because analyzer has no separate AST representation of a
+/// class body; it simply stores all of the relevant data in the
+/// [ClassDeclaration] object.

[ahe, 2017/02/20 13:04:39]

An alternative implementation is to simply push more values on the stack.

[Paul Berry, 2017/02/20 14:25:10]

Acknowledged.  I think I prefer using the temporary object, though, because it
lets me keep the invariant that every "handle..." method pops one element off
the stack per substructure.  If we start letting a substructure be represented
by multiple stack entries, then I have to think harder when I write a
"handle..." method to figure out which stack entry is which.

But if this data structure proves to be too much of a performance burden, I'll
definitely consider your suggestion.

+class _ClassBody {
+  final Token beginToken;
+
+  final List<ClassMember> members;
+
+  final Token endToken;
+
+  _ClassBody(this.beginToken, this.members, this.endToken);
+}
+
+/// Data structure placed on the stack to represent a mixin application (a
+/// structure of the form "A with B, C").
+///
+/// This is needed because analyzer has no separate AST representation of a
+/// mixin application; it simply stores all of the relevant data in the
+/// [ClassDeclaration] or [ClassTypeAlias] object.
+class _MixinApplication {
+  final TypeName supertype;
+
+  final Token withKeyword;
+
+  final List<TypeName> mixinTypes;
+
+  _MixinApplication(this.supertype, this.withKeyword, this.mixinTypes);
+}