Introduce common superclass to fix ClassElement.node (issue 23120)

pkg/analyzer/lib/src/generated/ast.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.ast;
 
 import 'dart:collection';
@@ skipping 3977 matching lines @@
 
 /**
  * The declaration of a class.
  *
  * > classDeclaration ::=
  * >     'abstract'? 'class' [SimpleIdentifier] [TypeParameterList]?
  * >     ([ExtendsClause] [WithClause]?)?
  * >     [ImplementsClause]?
  * >     '{' [ClassMember]* '}'
  */
-class ClassDeclaration extends CompilationUnitMember {
+class ClassDeclaration extends NamedCompilationUnitMember {
   /**
    * The 'abstract' keyword, or `null` if the keyword was absent.
    */
   Token abstractKeyword;
 
   /**
    * The token representing the 'class' keyword.
    */
   Token classKeyword;
 
   /**
-   * The name of the class being declared.
-   */
-  SimpleIdentifier _name;
-
-  /**
    * The type parameters for the class, or `null` if the class does not have any
    * type parameters.
    */
   TypeParameterList _typeParameters;
 
   /**
    * The extends clause for the class, or `null` if the class does not extend
    * any other class.
    */
   ExtendsClause _extendsClause;
@@ skipping 39 matching lines @@
    * have any type parameters. Any or all of the [extendsClause], [withClause],
    * and [implementsClause] can be `null` if the class does not have the
    * corresponding clause. The list of [members] can be `null` if the class does
    * not have any members.
    */
   ClassDeclaration(Comment comment, List<Annotation> metadata,
       this.abstractKeyword, this.classKeyword, SimpleIdentifier name,
       TypeParameterList typeParameters, ExtendsClause extendsClause,
       WithClause withClause, ImplementsClause implementsClause,
       this.leftBracket, List<ClassMember> members, this.rightBracket)
-      : super(comment, metadata) {
-    _name = _becomeParentOf(name);
+      : super(comment, metadata, name) {
     _typeParameters = _becomeParentOf(typeParameters);
     _extendsClause = _becomeParentOf(extendsClause);
     _withClause = _becomeParentOf(withClause);
     _implementsClause = _becomeParentOf(implementsClause);
     _members = new NodeList<ClassMember>(this, members);
   }
 
   @override
   Iterable get childEntities => super._childEntities
     ..add(abstractKeyword)
@@ skipping 53 matching lines @@
    * Return `true` if this class is declared to be an abstract class.
    */
   bool get isAbstract => abstractKeyword != null;
 
   /**
    * Return the members defined by the class.
    */
   NodeList<ClassMember> get members => _members;
 
   /**
-   * Return the name of the class being declared.
-   */
-  SimpleIdentifier get name => _name;
-
-  /**
-   * Set the name of the class being declared to the given [identifier].
-   */
-  void set name(SimpleIdentifier identifier) {
-    _name = _becomeParentOf(identifier);
-  }
-
-  /**
    * Return the native clause for this class, or `null` if the class does not
    * have a native clause.
    */
   NativeClause get nativeClause => _nativeClause;
 
   /**
    * Set the native clause for this class to the given [nativeClause].
    */
   void set nativeClause(NativeClause nativeClause) {
     _nativeClause = _becomeParentOf(nativeClause);
@@ skipping 117 matching lines @@
  * A class type alias.
  *
  * > classTypeAlias ::=
  * >     [SimpleIdentifier] [TypeParameterList]? '=' 'abstract'? mixinApplication
  * >
  * > mixinApplication ::=
  * >     [TypeName] [WithClause] [ImplementsClause]? ';'
  */
 class ClassTypeAlias extends TypeAlias {
   /**
-   * The name of the class being declared.
-   */
-  SimpleIdentifier _name;
-
-  /**
    * The type parameters for the class, or `null` if the class does not have any
    * type parameters.
    */
   TypeParameterList _typeParameters;
 
   /**
    * The token for the '=' separating the name from the definition.
    */
   Token equals;
 
@@ skipping 24 matching lines @@
    * [comment] and [metadata] can be `null` if the class type alias does not
    * have the corresponding attribute. The [typeParameters] can be `null` if the
    * class does not have any type parameters. The [abstractKeyword] can be
    * `null` if the class is not abstract. The [implementsClause] can be `null`
    * if the class does not implement any interfaces.
    */
   ClassTypeAlias(Comment comment, List<Annotation> metadata, Token keyword,
       SimpleIdentifier name, TypeParameterList typeParameters, this.equals,
       this.abstractKeyword, TypeName superclass, WithClause withClause,
       ImplementsClause implementsClause, Token semicolon)
-      : super(comment, metadata, keyword, semicolon) {
-    _name = _becomeParentOf(name);
+      : super(comment, metadata, keyword, name, semicolon) {
     _typeParameters = _becomeParentOf(typeParameters);
     _superclass = _becomeParentOf(superclass);
     _withClause = _becomeParentOf(withClause);
     _implementsClause = _becomeParentOf(implementsClause);
   }
 
   @override
   Iterable get childEntities => super._childEntities
     ..add(typedefKeyword)
     ..add(_name)
@@ skipping 21 matching lines @@
   void set implementsClause(ImplementsClause implementsClause) {
     _implementsClause = _becomeParentOf(implementsClause);
   }
 
   /**
    * Return `true` if this class is declared to be an abstract class.
    */
   bool get isAbstract => abstractKeyword != null;
 
   /**
-   * Return the name of the class being declared.
-   */
-  SimpleIdentifier get name => _name;
-
-  /**
-   * Set the name of the class being declared to the given [identifier].
-   */
-  void set name(SimpleIdentifier name) {
-    _name = _becomeParentOf(name);
-  }
-
-  /**
    * Return the name of the superclass of the class being declared.
    */
   TypeName get superclass => _superclass;
 
   /**
    * Set the name of the superclass of the class being declared to the given
    * [superclass] name.
    */
   void set superclass(TypeName superclass) {
     _superclass = _becomeParentOf(superclass);
@@ skipping 424 matching lines @@
       _declarations.accept(visitor);
     } else {
       for (AstNode child in sortedDirectivesAndDeclarations) {
         child.accept(visitor);
       }
     }
   }
 }
 
 /**
- * A node that declares a name within the scope of a compilation unit.
+ * A node that declares one or more names within the scope of a compilation
+ * unit.
  *
  * > compilationUnitMember ::=
  * >     [ClassDeclaration]
  * >   | [TypeAlias]
  * >   | [FunctionDeclaration]
  * >   | [MethodDeclaration]
  * >   | [VariableDeclaration]
  * >   | [VariableDeclaration]
  */
 abstract class CompilationUnitMember extends Declaration {
@@ skipping 1007 matching lines @@
   @override
   accept(AstVisitor visitor) => visitor.visitContinueStatement(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_label, visitor);
   }
 }
 
 /**
- * A node that represents the declaration of a name. Each declared name is
- * visible within a name scope.
+ * A node that represents the declaration of one or more names. Each declared
+ * name is visible within a name scope.
  */
 abstract class Declaration extends AnnotatedNode {
   /**
    * Initialize a newly created declaration. Either or both of the [comment] and
    * [metadata] can be `null` if the declaration does not have the corresponding
    * attribute.
    */
   Declaration(Comment comment, List<Annotation> metadata)
       : super(comment, metadata);
 
@@ skipping 707 matching lines @@
     _safelyVisitChild(_name, visitor);
   }
 }
 
 /**
  * The declaration of an enumeration.
  *
  * > enumType ::=
  * >     metadata 'enum' [SimpleIdentifier] '{' [SimpleIdentifier] (',' [SimpleIdentifier])* (',')? '}'
  */
-class EnumDeclaration extends CompilationUnitMember {
+class EnumDeclaration extends NamedCompilationUnitMember {
   /**
    * The 'enum' keyword.
    */
   Token enumKeyword;
 
   /**
-   * The name of the enumeration.
-   */
-  SimpleIdentifier _name;
-
-  /**
    * The left curly bracket.
    */
   Token leftBracket;
 
   /**
    * The enumeration constants being declared.
    */
   NodeList<EnumConstantDeclaration> _constants;
 
   /**
    * The right curly bracket.
    */
   Token rightBracket;
 
   /**
    * Initialize a newly created enumeration declaration. Either or both of the
    * [comment] and [metadata] can be `null` if the declaration does not have the
    * corresponding attribute. The list of [constants] must contain at least one
    * value.
    */
   EnumDeclaration(Comment comment, List<Annotation> metadata, this.enumKeyword,
       SimpleIdentifier name, this.leftBracket,
       List<EnumConstantDeclaration> constants, this.rightBracket)
-      : super(comment, metadata) {
-    _name = _becomeParentOf(name);
+      : super(comment, metadata, name) {
     _constants = new NodeList<EnumConstantDeclaration>(this, constants);
   }
 
   @override
   // TODO(brianwilkerson) Add commas?
   Iterable get childEntities => super._childEntities
     ..add(enumKeyword)
     ..add(_name)
     ..add(leftBracket)
     ..addAll(_constants)
@@ skipping 22 matching lines @@
   Token get keyword => enumKeyword;
 
   /**
    * Set the token for the 'enum' keyword to the given [token].
    */
   @deprecated // Use "this.enumKeyword"
   set keyword(Token token) {
     enumKeyword = token;
   }
 
-  /**
-   * Return the name of the enumeration.
-   */
-  SimpleIdentifier get name => _name;
-
-  /**
-   * Set the name of the enumeration to the given [name].
-   */
-  void set name(SimpleIdentifier name) {
-    _name = _becomeParentOf(name);
-  }
-
   @override
   accept(AstVisitor visitor) => visitor.visitEnumDeclaration(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _safelyVisitChild(_name, visitor);
     _constants.accept(visitor);
   }
 }
@@ skipping 1195 matching lines @@
 /**
  * A top-level declaration.
  *
  * > functionDeclaration ::=
  * >     'external' functionSignature
  * >   | functionSignature [FunctionBody]
  * >
  * > functionSignature ::=
  * >     [Type]? ('get' | 'set')? [SimpleIdentifier] [FormalParameterList]
  */
-class FunctionDeclaration extends CompilationUnitMember {
+class FunctionDeclaration extends NamedCompilationUnitMember {
   /**
    * The token representing the 'external' keyword, or `null` if this is not an
    * external function.
    */
   Token externalKeyword;
 
   /**
    * The return type of the function, or `null` if no return type was declared.
    */
   TypeName _returnType;
 
   /**
    * The token representing the 'get' or 'set' keyword, or `null` if this is a
    * function declaration rather than a property declaration.
    */
   Token propertyKeyword;
 
   /**
-   * The name of the function, or `null` if the function is not named.
-   */
-  SimpleIdentifier _name;
-
-  /**
    * The function expression being wrapped.
    */
   FunctionExpression _functionExpression;
 
   /**
    * Initialize a newly created function declaration. Either or both of the
    * [comment] and [metadata] can be `null` if the function does not have the
    * corresponding attribute. The [externalKeyword] can be `null` if the
    * function is not an external function. The [returnType] can be `null` if no
    * return type was specified. The [propertyKeyword] can be `null` if the
    * function is neither a getter or a setter.
    */
   FunctionDeclaration(Comment comment, List<Annotation> metadata,
       this.externalKeyword, TypeName returnType, this.propertyKeyword,
       SimpleIdentifier name, FunctionExpression functionExpression)
-      : super(comment, metadata) {
+      : super(comment, metadata, name) {
     _returnType = _becomeParentOf(returnType);
-    _name = _becomeParentOf(name);
     _functionExpression = _becomeParentOf(functionExpression);
   }
 
   @override
   Iterable get childEntities => super._childEntities
     ..add(externalKeyword)
     ..add(_returnType)
     ..add(propertyKeyword)
     ..add(_name)
     ..add(_functionExpression);
@@ skipping 38 matching lines @@
   bool get isGetter => propertyKeyword != null &&
       (propertyKeyword as KeywordToken).keyword == Keyword.GET;
 
   /**
    * Return `true` if this function declares a setter.
    */
   bool get isSetter => propertyKeyword != null &&
       (propertyKeyword as KeywordToken).keyword == Keyword.SET;
 
   /**
-   * Return the name of the function, or `null` if the function is not named.
-   */
-  SimpleIdentifier get name => _name;
-
-  /**
-   * Set the name of the function to the given [identifier].
-   */
-  void set name(SimpleIdentifier identifier) {
-    _name = _becomeParentOf(identifier);
-  }
-
-  /**
    * Return the return type of the function, or `null` if no return type was
    * declared.
    */
   TypeName get returnType => _returnType;
 
   /**
    * Set the return type of the function to the given [returnType].
    */
   void set returnType(TypeName returnType) {
     _returnType = _becomeParentOf(returnType);
@@ skipping 272 matching lines @@
  * >     [TypeName]? [SimpleIdentifier]
  */
 class FunctionTypeAlias extends TypeAlias {
   /**
    * The name of the return type of the function type being defined, or `null`
    * if no return type was given.
    */
   TypeName _returnType;
 
   /**
-   * The name of the function type being declared.
-   */
-  SimpleIdentifier _name;
-
-  /**
    * The type parameters for the function type, or `null` if the function type
    * does not have any type parameters.
    */
   TypeParameterList _typeParameters;
 
   /**
    * The parameters associated with the function type.
    */
   FormalParameterList _parameters;
 
   /**
    * Initialize a newly created function type alias. Either or both of the
    * [comment] and [metadata] can be `null` if the function does not have the
    * corresponding attribute. The [returnType] can be `null` if no return type
    * was specified. The [typeParameters] can be `null` if the function has no
    * type parameters.
    */
   FunctionTypeAlias(Comment comment, List<Annotation> metadata, Token keyword,
       TypeName returnType, SimpleIdentifier name,
       TypeParameterList typeParameters, FormalParameterList parameters,
       Token semicolon)
-      : super(comment, metadata, keyword, semicolon) {
+      : super(comment, metadata, keyword, name, semicolon) {
     _returnType = _becomeParentOf(returnType);
-    _name = _becomeParentOf(name);
     _typeParameters = _becomeParentOf(typeParameters);
     _parameters = _becomeParentOf(parameters);
   }
 
   @override
   Iterable get childEntities => super._childEntities
     ..add(typedefKeyword)
     ..add(_returnType)
     ..add(_name)
     ..add(_typeParameters)
     ..add(_parameters)
     ..add(semicolon);
 
   @override
   FunctionTypeAliasElement get element =>
       _name != null ? (_name.staticElement as FunctionTypeAliasElement) : null;
 
   /**
-   * Return the name of the function type being declared.
-   */
-  SimpleIdentifier get name => _name;
-
-  /**
-   * Set the name of the function type being declared to the given [name].
-   */
-  void set name(SimpleIdentifier name) {
-    _name = _becomeParentOf(name);
-  }
-
-  /**
    * Return the parameters associated with the function type.
    */
   FormalParameterList get parameters => _parameters;
 
   /**
    * Set the parameters associated with the function type to the given list of
    * [parameters].
    */
   void set parameters(FormalParameterList parameters) {
     _parameters = _becomeParentOf(parameters);
@@ skipping 191 matching lines @@
   R visitBreakStatement(BreakStatement node) => visitStatement(node);
 
   @override
   R visitCascadeExpression(CascadeExpression node) => visitExpression(node);
 
   @override
   R visitCatchClause(CatchClause node) => visitNode(node);
 
   @override
   R visitClassDeclaration(ClassDeclaration node) =>
-      visitCompilationUnitMember(node);
+      visitNamedCompilationUnitMember(node);
 
   R visitClassMember(ClassMember node) => visitDeclaration(node);
 
   @override
   R visitClassTypeAlias(ClassTypeAlias node) => visitTypeAlias(node);
 
   R visitCombinator(Combinator node) => visitNode(node);
 
   @override
   R visitComment(Comment node) => visitNode(node);
@@ skipping 49 matching lines @@
 
   @override
   R visitEmptyStatement(EmptyStatement node) => visitStatement(node);
 
   @override
   R visitEnumConstantDeclaration(EnumConstantDeclaration node) =>
       visitDeclaration(node);
 
   @override
   R visitEnumDeclaration(EnumDeclaration node) =>
-      visitCompilationUnitMember(node);
+      visitNamedCompilationUnitMember(node);
 
   @override
   R visitExportDirective(ExportDirective node) => visitNamespaceDirective(node);
 
   R visitExpression(Expression node) => visitNode(node);
 
   @override
   R visitExpressionFunctionBody(ExpressionFunctionBody node) =>
       visitFunctionBody(node);
 
@@ skipping 18 matching lines @@
   @override
   R visitFormalParameterList(FormalParameterList node) => visitNode(node);
 
   @override
   R visitForStatement(ForStatement node) => visitStatement(node);
 
   R visitFunctionBody(FunctionBody node) => visitNode(node);
 
   @override
   R visitFunctionDeclaration(FunctionDeclaration node) =>
-      visitCompilationUnitMember(node);
+      visitNamedCompilationUnitMember(node);
 
   @override
   R visitFunctionDeclarationStatement(FunctionDeclarationStatement node) =>
       visitStatement(node);
 
   @override
   R visitFunctionExpression(FunctionExpression node) => visitExpression(node);
 
   @override
   R visitFunctionExpressionInvocation(FunctionExpressionInvocation node) =>
@@ skipping 65 matching lines @@
 
   @override
   R visitMapLiteralEntry(MapLiteralEntry node) => visitNode(node);
 
   @override
   R visitMethodDeclaration(MethodDeclaration node) => visitClassMember(node);
 
   @override
   R visitMethodInvocation(MethodInvocation node) => visitExpression(node);
 
+  R visitNamedCompilationUnitMember(NamedCompilationUnitMember node) =>
+      visitCompilationUnitMember(node);
+
   @override
   R visitNamedExpression(NamedExpression node) => visitExpression(node);
 
   R visitNamespaceDirective(NamespaceDirective node) =>
       visitUriBasedDirective(node);
 
   @override
   R visitNativeClause(NativeClause node) => visitNode(node);
 
   @override
@@ skipping 98 matching lines @@
   @override
   R visitThrowExpression(ThrowExpression node) => visitExpression(node);
 
   @override
   R visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) =>
       visitCompilationUnitMember(node);
 
   @override
   R visitTryStatement(TryStatement node) => visitStatement(node);
 
-  R visitTypeAlias(TypeAlias node) => visitCompilationUnitMember(node);
+  R visitTypeAlias(TypeAlias node) => visitNamedCompilationUnitMember(node);
 
   @override
   R visitTypeArgumentList(TypeArgumentList node) => visitNode(node);
 
   R visitTypedLiteral(TypedLiteral node) => visitLiteral(node);
 
   @override
   R visitTypeName(TypeName node) => visitNode(node);
 
   @override
@@ skipping 3010 matching lines @@
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_target, visitor);
     _safelyVisitChild(_methodName, visitor);
     _safelyVisitChild(_argumentList, visitor);
   }
 }
 
 /**
+ * A node that declares a single name within the scope of a compilation unit.
+ */
+abstract class NamedCompilationUnitMember extends CompilationUnitMember {
+  /**
+   * The name of the member being declared.
+   */
+  SimpleIdentifier _name;
+
+  /**
+   * Initialize a newly created compilation unit member with the given [name].
+   * Either or both of the [comment] and [metadata] can be `null` if the member
+   * does not have the corresponding attribute.
+   */
+  NamedCompilationUnitMember(
+      Comment comment, List<Annotation> metadata, SimpleIdentifier name)
+      : super(comment, metadata) {
+    _name = _becomeParentOf(name);
+  }
+
+  /**
+   * Return the name of the member being declared.
+   */
+  SimpleIdentifier get name => _name;
+
+  /**
+   * Set the name of the member being declared to the given [identifier].
+   */
+  void set name(SimpleIdentifier identifier) {
+    _name = _becomeParentOf(identifier);
+  }
+}
+
+/**
  * An expression that has a name associated with it. They are used in method
  * invocations when there are named parameters.
  *
  * > namedExpression ::=
  * >     [Label] [Expression]
  */
 class NamedExpression extends Expression {
   /**
    * The name associated with the expression.
    */
@@ skipping 6784 matching lines @@
 /**
  * The declaration of a type alias.
  *
  * > typeAlias ::=
  * >     'typedef' typeAliasBody
  * >
  * > typeAliasBody ::=
  * >     classTypeAlias
  * >   | functionTypeAlias
  */
-abstract class TypeAlias extends CompilationUnitMember {
+abstract class TypeAlias extends NamedCompilationUnitMember {
   /**
    * The token representing the 'typedef' keyword.
    */
   Token typedefKeyword;
 
   /**
    * The semicolon terminating the declaration.
    */
   Token semicolon;
 
   /**
    * Initialize a newly created type alias. Either or both of the [comment] and
    * [metadata] can be `null` if the declaration does not have the corresponding
    * attribute.
    */
   TypeAlias(Comment comment, List<Annotation> metadata, this.typedefKeyword,
-      this.semicolon)
-      : super(comment, metadata);
+      SimpleIdentifier name, this.semicolon)
+      : super(comment, metadata, name);
 
   @override
   Token get endToken => semicolon;
 
   @override
   Token get firstTokenAfterCommentAndMetadata => typedefKeyword;
 
   /**
    * Return the token representing the 'typedef' keyword.
    */
@@ skipping 1392 matching lines @@
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitYieldStatement(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_expression, visitor);
   }
 }