| Index: analyzer/lib/src/generated/ast.dart
|
| diff --git a/analyzer/lib/src/generated/ast.dart b/analyzer/lib/src/generated/ast.dart
|
| deleted file mode 100644
|
| index c386c83fcab0672f524116a05d294237a7b8c1f6..0000000000000000000000000000000000000000
|
| --- a/analyzer/lib/src/generated/ast.dart
|
| +++ /dev/null
|
| @@ -1,20216 +0,0 @@
|
| -// 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';
|
| -
|
| -import 'element.dart';
|
| -import 'engine.dart' show AnalysisEngine;
|
| -import 'java_core.dart';
|
| -import 'java_engine.dart';
|
| -import 'parser.dart';
|
| -import 'scanner.dart';
|
| -import 'source.dart' show LineInfo, Source;
|
| -import 'utilities_collection.dart' show TokenMap;
|
| -import 'utilities_dart.dart';
|
| -
|
| -/**
|
| - * Two or more string literals that are implicitly concatenated because of being
|
| - * adjacent (separated only by whitespace).
|
| - *
|
| - * While the grammar only allows adjacent strings when all of the strings are of
|
| - * the same kind (single line or multi-line), this class doesn't enforce that
|
| - * restriction.
|
| - *
|
| - * > adjacentStrings ::=
|
| - * > [StringLiteral] [StringLiteral]+
|
| - */
|
| -class AdjacentStrings extends StringLiteral {
|
| - /**
|
| - * The strings that are implicitly concatenated.
|
| - */
|
| - NodeList<StringLiteral> _strings;
|
| -
|
| - /**
|
| - * Initialize a newly created list of adjacent strings. To be syntactically
|
| - * valid, the list of [strings] must contain at least two elements.
|
| - */
|
| - AdjacentStrings(List<StringLiteral> strings) {
|
| - _strings = new NodeList<StringLiteral>(this, strings);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => _strings.beginToken;
|
| -
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()..addAll(_strings);
|
| -
|
| - @override
|
| - Token get endToken => _strings.endToken;
|
| -
|
| - /**
|
| - * Return the strings that are implicitly concatenated.
|
| - */
|
| - NodeList<StringLiteral> get strings => _strings;
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitAdjacentStrings(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _strings.accept(visitor);
|
| - }
|
| -
|
| - @override
|
| - void _appendStringValue(StringBuffer buffer) {
|
| - for (StringLiteral stringLiteral in strings) {
|
| - stringLiteral._appendStringValue(buffer);
|
| - }
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * An AST node that can be annotated with both a documentation comment and a
|
| - * list of annotations.
|
| - */
|
| -abstract class AnnotatedNode extends AstNode {
|
| - /**
|
| - * The documentation comment associated with this node, or `null` if this node
|
| - * does not have a documentation comment associated with it.
|
| - */
|
| - Comment _comment;
|
| -
|
| - /**
|
| - * The annotations associated with this node.
|
| - */
|
| - NodeList<Annotation> _metadata;
|
| -
|
| - /**
|
| - * Initialize a newly created annotated node. Either or both of the [comment]
|
| - * and [metadata] can be `null` if the node does not have the corresponding
|
| - * attribute.
|
| - */
|
| - AnnotatedNode(Comment comment, List<Annotation> metadata) {
|
| - _comment = _becomeParentOf(comment);
|
| - _metadata = new NodeList<Annotation>(this, metadata);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken {
|
| - if (_comment == null) {
|
| - if (_metadata.isEmpty) {
|
| - return firstTokenAfterCommentAndMetadata;
|
| - }
|
| - return _metadata.beginToken;
|
| - } else if (_metadata.isEmpty) {
|
| - return _comment.beginToken;
|
| - }
|
| - Token commentToken = _comment.beginToken;
|
| - Token metadataToken = _metadata.beginToken;
|
| - if (commentToken.offset < metadataToken.offset) {
|
| - return commentToken;
|
| - }
|
| - return metadataToken;
|
| - }
|
| -
|
| - /**
|
| - * Return the documentation comment associated with this node, or `null` if
|
| - * this node does not have a documentation comment associated with it.
|
| - */
|
| - Comment get documentationComment => _comment;
|
| -
|
| - /**
|
| - * Set the documentation comment associated with this node to the given
|
| - * [comment].
|
| - */
|
| - void set documentationComment(Comment comment) {
|
| - _comment = _becomeParentOf(comment);
|
| - }
|
| -
|
| - /**
|
| - * Return the first token following the comment and metadata.
|
| - */
|
| - Token get firstTokenAfterCommentAndMetadata;
|
| -
|
| - /**
|
| - * Return the annotations associated with this node.
|
| - */
|
| - NodeList<Annotation> get metadata => _metadata;
|
| -
|
| - /**
|
| - * Set the metadata associated with this node to the given [metadata].
|
| - */
|
| - @deprecated // Directly modify the list returned by "this.metadata"
|
| - void set metadata(List<Annotation> metadata) {
|
| - _metadata.clear();
|
| - _metadata.addAll(metadata);
|
| - }
|
| -
|
| - /**
|
| - * Return a list containing the comment and annotations associated with this
|
| - * node, sorted in lexical order.
|
| - */
|
| - List<AstNode> get sortedCommentAndAnnotations {
|
| - return <AstNode>[]
|
| - ..add(_comment)
|
| - ..addAll(_metadata)
|
| - ..sort(AstNode.LEXICAL_ORDER);
|
| - }
|
| -
|
| - /**
|
| - * Return a holder of child entities that subclasses can add to.
|
| - */
|
| - ChildEntities get _childEntities {
|
| - ChildEntities result = new ChildEntities();
|
| - if (_commentIsBeforeAnnotations()) {
|
| - result
|
| - ..add(_comment)
|
| - ..addAll(_metadata);
|
| - } else {
|
| - result.addAll(sortedCommentAndAnnotations);
|
| - }
|
| - return result;
|
| - }
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - if (_commentIsBeforeAnnotations()) {
|
| - _safelyVisitChild(_comment, visitor);
|
| - _metadata.accept(visitor);
|
| - } else {
|
| - for (AstNode child in sortedCommentAndAnnotations) {
|
| - child.accept(visitor);
|
| - }
|
| - }
|
| - }
|
| -
|
| - /**
|
| - * Return `true` if there are no annotations before the comment. Note that a
|
| - * result of `true` does not imply that there is a comment, nor that there are
|
| - * annotations associated with this node.
|
| - */
|
| - bool _commentIsBeforeAnnotations() {
|
| - // TODO(brianwilkerson) Convert this to a getter.
|
| - if (_comment == null || _metadata.isEmpty) {
|
| - return true;
|
| - }
|
| - Annotation firstAnnotation = _metadata[0];
|
| - return _comment.offset < firstAnnotation.offset;
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * An annotation that can be associated with an AST node.
|
| - *
|
| - * > metadata ::=
|
| - * > annotation*
|
| - * >
|
| - * > annotation ::=
|
| - * > '@' [Identifier] ('.' [SimpleIdentifier])? [ArgumentList]?
|
| - */
|
| -class Annotation extends AstNode {
|
| - /**
|
| - * The at sign that introduced the annotation.
|
| - */
|
| - Token atSign;
|
| -
|
| - /**
|
| - * The name of the class defining the constructor that is being invoked or the
|
| - * name of the field that is being referenced.
|
| - */
|
| - Identifier _name;
|
| -
|
| - /**
|
| - * The period before the constructor name, or `null` if this annotation is not
|
| - * the invocation of a named constructor.
|
| - */
|
| - Token period;
|
| -
|
| - /**
|
| - * The name of the constructor being invoked, or `null` if this annotation is
|
| - * not the invocation of a named constructor.
|
| - */
|
| - SimpleIdentifier _constructorName;
|
| -
|
| - /**
|
| - * The arguments to the constructor being invoked, or `null` if this
|
| - * annotation is not the invocation of a constructor.
|
| - */
|
| - ArgumentList _arguments;
|
| -
|
| - /**
|
| - * The element associated with this annotation, or `null` if the AST structure
|
| - * has not been resolved or if this annotation could not be resolved.
|
| - */
|
| - Element _element;
|
| -
|
| - /**
|
| - * The element annotation representing this annotation in the element model.
|
| - */
|
| - ElementAnnotation elementAnnotation;
|
| -
|
| - /**
|
| - * Initialize a newly created annotation. Both the [period] and the
|
| - * [constructorName] can be `null` if the annotation is not referencing a
|
| - * named constructor. The [arguments] can be `null` if the annotation is not
|
| - * referencing a constructor.
|
| - */
|
| - Annotation(this.atSign, Identifier name, this.period,
|
| - SimpleIdentifier constructorName, ArgumentList arguments) {
|
| - _name = _becomeParentOf(name);
|
| - _constructorName = _becomeParentOf(constructorName);
|
| - _arguments = _becomeParentOf(arguments);
|
| - }
|
| -
|
| - /**
|
| - * Return the arguments to the constructor being invoked, or `null` if this
|
| - * annotation is not the invocation of a constructor.
|
| - */
|
| - ArgumentList get arguments => _arguments;
|
| -
|
| - /**
|
| - * Set the arguments to the constructor being invoked to the given arguments.
|
| - */
|
| - void set arguments(ArgumentList arguments) {
|
| - _arguments = _becomeParentOf(arguments);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => atSign;
|
| -
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()
|
| - ..add(atSign)
|
| - ..add(_name)
|
| - ..add(period)
|
| - ..add(_constructorName)
|
| - ..add(_arguments);
|
| -
|
| - /**
|
| - * Return the name of the constructor being invoked, or `null` if this
|
| - * annotation is not the invocation of a named constructor.
|
| - */
|
| - SimpleIdentifier get constructorName => _constructorName;
|
| -
|
| - /**
|
| - * Set the name of the constructor being invoked to the given [name].
|
| - */
|
| - void set constructorName(SimpleIdentifier name) {
|
| - _constructorName = _becomeParentOf(name);
|
| - }
|
| -
|
| - /**
|
| - * Return the element associated with this annotation, or `null` if the AST
|
| - * structure has not been resolved or if this annotation could not be
|
| - * resolved.
|
| - */
|
| - Element get element {
|
| - if (_element != null) {
|
| - return _element;
|
| - } else if (_name != null) {
|
| - return _name.staticElement;
|
| - }
|
| - return null;
|
| - }
|
| -
|
| - /**
|
| - * Set the element associated with this annotation to the given [element].
|
| - */
|
| - void set element(Element element) {
|
| - _element = element;
|
| - }
|
| -
|
| - @override
|
| - Token get endToken {
|
| - if (_arguments != null) {
|
| - return _arguments.endToken;
|
| - } else if (_constructorName != null) {
|
| - return _constructorName.endToken;
|
| - }
|
| - return _name.endToken;
|
| - }
|
| -
|
| - /**
|
| - * Return the name of the class defining the constructor that is being invoked
|
| - * or the name of the field that is being referenced.
|
| - */
|
| - Identifier get name => _name;
|
| -
|
| - /**
|
| - * Set the name of the class defining the constructor that is being invoked or
|
| - * the name of the field that is being referenced to the given [name].
|
| - */
|
| - void set name(Identifier name) {
|
| - _name = _becomeParentOf(name);
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitAnnotation(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_name, visitor);
|
| - _safelyVisitChild(_constructorName, visitor);
|
| - _safelyVisitChild(_arguments, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A list of arguments in the invocation of an executable element (that is, a
|
| - * function, method, or constructor).
|
| - *
|
| - * > argumentList ::=
|
| - * > '(' arguments? ')'
|
| - * >
|
| - * > arguments ::=
|
| - * > [NamedExpression] (',' [NamedExpression])*
|
| - * > | [Expression] (',' [Expression])* (',' [NamedExpression])*
|
| - */
|
| -class ArgumentList extends AstNode {
|
| - /**
|
| - * The left parenthesis.
|
| - */
|
| - Token leftParenthesis;
|
| -
|
| - /**
|
| - * The expressions producing the values of the arguments.
|
| - */
|
| - NodeList<Expression> _arguments;
|
| -
|
| - /**
|
| - * The right parenthesis.
|
| - */
|
| - Token rightParenthesis;
|
| -
|
| - /**
|
| - * A list containing the elements representing the parameters corresponding to
|
| - * each of the arguments in this list, or `null` if the AST has not been
|
| - * resolved or if the function or method being invoked could not be determined
|
| - * based on static type information. The list must be the same length as the
|
| - * number of arguments, but can contain `null` entries if a given argument
|
| - * does not correspond to a formal parameter.
|
| - */
|
| - List<ParameterElement> _correspondingStaticParameters;
|
| -
|
| - /**
|
| - * A list containing the elements representing the parameters corresponding to
|
| - * each of the arguments in this list, or `null` if the AST has not been
|
| - * resolved or if the function or method being invoked could not be determined
|
| - * based on propagated type information. The list must be the same length as
|
| - * the number of arguments, but can contain `null` entries if a given argument
|
| - * does not correspond to a formal parameter.
|
| - */
|
| - List<ParameterElement> _correspondingPropagatedParameters;
|
| -
|
| - /**
|
| - * Initialize a newly created list of arguments. The list of [arguments] can
|
| - * be `null` if there are no arguments.
|
| - */
|
| - ArgumentList(
|
| - this.leftParenthesis, List<Expression> arguments, this.rightParenthesis) {
|
| - _arguments = new NodeList<Expression>(this, arguments);
|
| - }
|
| -
|
| - /**
|
| - * Return the expressions producing the values of the arguments. Although the
|
| - * language requires that positional arguments appear before named arguments,
|
| - * this class allows them to be intermixed.
|
| - */
|
| - NodeList<Expression> get arguments => _arguments;
|
| -
|
| - @override
|
| - Token get beginToken => leftParenthesis;
|
| -
|
| - /**
|
| - * TODO(paulberry): Add commas.
|
| - */
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()
|
| - ..add(leftParenthesis)
|
| - ..addAll(_arguments)
|
| - ..add(rightParenthesis);
|
| -
|
| - /**
|
| - * Set the parameter elements corresponding to each of the arguments in this
|
| - * list to the given list of [parameters]. The list of parameters must be the
|
| - * same length as the number of arguments, but can contain `null` entries if a
|
| - * given argument does not correspond to a formal parameter.
|
| - */
|
| - void set correspondingPropagatedParameters(
|
| - List<ParameterElement> parameters) {
|
| - if (parameters.length != _arguments.length) {
|
| - throw new IllegalArgumentException(
|
| - "Expected ${_arguments.length} parameters, not ${parameters.length}");
|
| - }
|
| - _correspondingPropagatedParameters = parameters;
|
| - }
|
| -
|
| - /**
|
| - * Set the parameter elements corresponding to each of the arguments in this
|
| - * list to the given list of parameters. The list of parameters must be the
|
| - * same length as the number of arguments, but can contain `null` entries if a
|
| - * given argument does not correspond to a formal parameter.
|
| - */
|
| - void set correspondingStaticParameters(List<ParameterElement> parameters) {
|
| - if (parameters.length != _arguments.length) {
|
| - throw new IllegalArgumentException(
|
| - "Expected ${_arguments.length} parameters, not ${parameters.length}");
|
| - }
|
| - _correspondingStaticParameters = parameters;
|
| - }
|
| -
|
| - @override
|
| - Token get endToken => rightParenthesis;
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitArgumentList(this);
|
| -
|
| - /**
|
| - * If
|
| - * * the given [expression] is a child of this list,
|
| - * * the AST structure has been resolved,
|
| - * * the function being invoked is known based on propagated type information,
|
| - * and
|
| - * * the expression corresponds to one of the parameters of the function being
|
| - * invoked,
|
| - * then return the parameter element representing the parameter to which the
|
| - * value of the given expression will be bound. Otherwise, return `null`.
|
| - */
|
| - @deprecated // Use "expression.propagatedParameterElement"
|
| - ParameterElement getPropagatedParameterElementFor(Expression expression) {
|
| - return _getPropagatedParameterElementFor(expression);
|
| - }
|
| -
|
| - /**
|
| - * If
|
| - * * the given [expression] is a child of this list,
|
| - * * the AST structure has been resolved,
|
| - * * the function being invoked is known based on static type information, and
|
| - * * the expression corresponds to one of the parameters of the function being
|
| - * invoked,
|
| - * then return the parameter element representing the parameter to which the
|
| - * value of the given expression will be bound. Otherwise, return `null`.
|
| - */
|
| - @deprecated // Use "expression.staticParameterElement"
|
| - ParameterElement getStaticParameterElementFor(Expression expression) {
|
| - return _getStaticParameterElementFor(expression);
|
| - }
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _arguments.accept(visitor);
|
| - }
|
| -
|
| - /**
|
| - * If
|
| - * * the given [expression] is a child of this list,
|
| - * * the AST structure has been resolved,
|
| - * * the function being invoked is known based on propagated type information,
|
| - * and
|
| - * * the expression corresponds to one of the parameters of the function being
|
| - * invoked,
|
| - * then return the parameter element representing the parameter to which the
|
| - * value of the given expression will be bound. Otherwise, return `null`.
|
| - */
|
| - ParameterElement _getPropagatedParameterElementFor(Expression expression) {
|
| - if (_correspondingPropagatedParameters == null ||
|
| - _correspondingPropagatedParameters.length != _arguments.length) {
|
| - // Either the AST structure has not been resolved, the invocation of which
|
| - // this list is a part could not be resolved, or the argument list was
|
| - // modified after the parameters were set.
|
| - return null;
|
| - }
|
| - int index = _arguments.indexOf(expression);
|
| - if (index < 0) {
|
| - // The expression isn't a child of this node.
|
| - return null;
|
| - }
|
| - return _correspondingPropagatedParameters[index];
|
| - }
|
| -
|
| - /**
|
| - * If
|
| - * * the given [expression] is a child of this list,
|
| - * * the AST structure has been resolved,
|
| - * * the function being invoked is known based on static type information, and
|
| - * * the expression corresponds to one of the parameters of the function being
|
| - * invoked,
|
| - * then return the parameter element representing the parameter to which the
|
| - * value of the given expression will be bound. Otherwise, return `null`.
|
| - */
|
| - ParameterElement _getStaticParameterElementFor(Expression expression) {
|
| - if (_correspondingStaticParameters == null ||
|
| - _correspondingStaticParameters.length != _arguments.length) {
|
| - // Either the AST structure has not been resolved, the invocation of which
|
| - // this list is a part could not be resolved, or the argument list was
|
| - // modified after the parameters were set.
|
| - return null;
|
| - }
|
| - int index = _arguments.indexOf(expression);
|
| - if (index < 0) {
|
| - // The expression isn't a child of this node.
|
| - return null;
|
| - }
|
| - return _correspondingStaticParameters[index];
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * An as expression.
|
| - *
|
| - * > asExpression ::=
|
| - * > [Expression] 'as' [TypeName]
|
| - */
|
| -class AsExpression extends Expression {
|
| - /**
|
| - * The expression used to compute the value being cast.
|
| - */
|
| - Expression _expression;
|
| -
|
| - /**
|
| - * The 'as' operator.
|
| - */
|
| - Token asOperator;
|
| -
|
| - /**
|
| - * The name of the type being cast to.
|
| - */
|
| - TypeName _type;
|
| -
|
| - /**
|
| - * Initialize a newly created as expression.
|
| - */
|
| - AsExpression(Expression expression, this.asOperator, TypeName type) {
|
| - _expression = _becomeParentOf(expression);
|
| - _type = _becomeParentOf(type);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => _expression.beginToken;
|
| -
|
| - @override
|
| - Iterable get childEntities =>
|
| - new ChildEntities()..add(_expression)..add(asOperator)..add(_type);
|
| -
|
| - @override
|
| - Token get endToken => _type.endToken;
|
| -
|
| - /**
|
| - * Return the expression used to compute the value being cast.
|
| - */
|
| - Expression get expression => _expression;
|
| -
|
| - /**
|
| - * Set the expression used to compute the value being cast to the given
|
| - * [expression].
|
| - */
|
| - void set expression(Expression expression) {
|
| - _expression = _becomeParentOf(expression);
|
| - }
|
| -
|
| - @override
|
| - int get precedence => 7;
|
| -
|
| - /**
|
| - * Return the name of the type being cast to.
|
| - */
|
| - TypeName get type => _type;
|
| -
|
| - /**
|
| - * Set the name of the type being cast to to the given [name].
|
| - */
|
| - void set type(TypeName name) {
|
| - _type = _becomeParentOf(name);
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitAsExpression(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_expression, visitor);
|
| - _safelyVisitChild(_type, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * An assert statement.
|
| - *
|
| - * > assertStatement ::=
|
| - * > 'assert' '(' [Expression] ')' ';'
|
| - */
|
| -class AssertStatement extends Statement {
|
| - /**
|
| - * The token representing the 'assert' keyword.
|
| - */
|
| - Token assertKeyword;
|
| -
|
| - /**
|
| - * The left parenthesis.
|
| - */
|
| - Token leftParenthesis;
|
| -
|
| - /**
|
| - * The condition that is being asserted to be `true`.
|
| - */
|
| - Expression _condition;
|
| -
|
| - /**
|
| - * The right parenthesis.
|
| - */
|
| - Token rightParenthesis;
|
| -
|
| - /**
|
| - * The semicolon terminating the statement.
|
| - */
|
| - Token semicolon;
|
| -
|
| - /**
|
| - * Initialize a newly created assert statement.
|
| - */
|
| - AssertStatement(this.assertKeyword, this.leftParenthesis,
|
| - Expression condition, this.rightParenthesis, this.semicolon) {
|
| - _condition = _becomeParentOf(condition);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => assertKeyword;
|
| -
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()
|
| - ..add(assertKeyword)
|
| - ..add(leftParenthesis)
|
| - ..add(_condition)
|
| - ..add(rightParenthesis)
|
| - ..add(semicolon);
|
| -
|
| - /**
|
| - * Return the condition that is being asserted to be `true`.
|
| - */
|
| - Expression get condition => _condition;
|
| -
|
| - /**
|
| - * Set the condition that is being asserted to be `true` to the given
|
| - * [expression].
|
| - */
|
| - void set condition(Expression condition) {
|
| - _condition = _becomeParentOf(condition);
|
| - }
|
| -
|
| - @override
|
| - Token get endToken => semicolon;
|
| -
|
| - /**
|
| - * Return the token representing the 'assert' keyword.
|
| - */
|
| - @deprecated // Use "this.assertKeyword"
|
| - Token get keyword => assertKeyword;
|
| -
|
| - /**
|
| - * Set the token representing the 'assert' keyword to the given [token].
|
| - */
|
| - @deprecated // Use "this.assertKeyword"
|
| - set keyword(Token token) {
|
| - assertKeyword = token;
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitAssertStatement(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_condition, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * An assignment expression.
|
| - *
|
| - * > assignmentExpression ::=
|
| - * > [Expression] operator [Expression]
|
| - */
|
| -class AssignmentExpression extends Expression {
|
| - /**
|
| - * The expression used to compute the left hand side.
|
| - */
|
| - Expression _leftHandSide;
|
| -
|
| - /**
|
| - * The assignment operator being applied.
|
| - */
|
| - Token operator;
|
| -
|
| - /**
|
| - * The expression used to compute the right hand side.
|
| - */
|
| - Expression _rightHandSide;
|
| -
|
| - /**
|
| - * The element associated with the operator based on the static type of the
|
| - * left-hand-side, or `null` if the AST structure has not been resolved, if
|
| - * the operator is not a compound operator, or if the operator could not be
|
| - * resolved.
|
| - */
|
| - MethodElement staticElement;
|
| -
|
| - /**
|
| - * The element associated with the operator based on the propagated type of
|
| - * the left-hand-side, or `null` if the AST structure has not been resolved,
|
| - * if the operator is not a compound operator, or if the operator could not be
|
| - * resolved.
|
| - */
|
| - MethodElement propagatedElement;
|
| -
|
| - /**
|
| - * Initialize a newly created assignment expression.
|
| - */
|
| - AssignmentExpression(
|
| - Expression leftHandSide, this.operator, Expression rightHandSide) {
|
| - if (leftHandSide == null || rightHandSide == null) {
|
| - String message;
|
| - if (leftHandSide == null) {
|
| - if (rightHandSide == null) {
|
| - message = "Both the left-hand and right-hand sides are null";
|
| - } else {
|
| - message = "The left-hand size is null";
|
| - }
|
| - } else {
|
| - message = "The right-hand size is null";
|
| - }
|
| - AnalysisEngine.instance.logger.logError(
|
| - message, new CaughtException(new AnalysisException(message), null));
|
| - }
|
| - _leftHandSide = _becomeParentOf(leftHandSide);
|
| - _rightHandSide = _becomeParentOf(rightHandSide);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => _leftHandSide.beginToken;
|
| -
|
| - /**
|
| - * Return the best element available for this operator. If resolution was able
|
| - * to find a better element based on type propagation, that element will be
|
| - * returned. Otherwise, the element found using the result of static analysis
|
| - * will be returned. If resolution has not been performed, then `null` will be
|
| - * returned.
|
| - */
|
| - MethodElement get bestElement {
|
| - MethodElement element = propagatedElement;
|
| - if (element == null) {
|
| - element = staticElement;
|
| - }
|
| - return element;
|
| - }
|
| -
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()
|
| - ..add(_leftHandSide)
|
| - ..add(operator)
|
| - ..add(_rightHandSide);
|
| -
|
| - @override
|
| - Token get endToken => _rightHandSide.endToken;
|
| -
|
| - /**
|
| - * Set the expression used to compute the left hand side to the given
|
| - * [expression].
|
| - */
|
| - Expression get leftHandSide => _leftHandSide;
|
| -
|
| - /**
|
| - * Return the expression used to compute the left hand side.
|
| - */
|
| - void set leftHandSide(Expression expression) {
|
| - _leftHandSide = _becomeParentOf(expression);
|
| - }
|
| -
|
| - @override
|
| - int get precedence => 1;
|
| -
|
| - /**
|
| - * If the AST structure has been resolved, and the function being invoked is
|
| - * known based on propagated type information, then return the parameter
|
| - * element representing the parameter to which the value of the right operand
|
| - * will be bound. Otherwise, return `null`.
|
| - */
|
| - @deprecated // Use "expression.propagatedParameterElement"
|
| - ParameterElement get propagatedParameterElementForRightHandSide {
|
| - return _propagatedParameterElementForRightHandSide;
|
| - }
|
| -
|
| - /**
|
| - * Return the expression used to compute the right hand side.
|
| - */
|
| - Expression get rightHandSide => _rightHandSide;
|
| -
|
| - /**
|
| - * Set the expression used to compute the left hand side to the given
|
| - * [expression].
|
| - */
|
| - void set rightHandSide(Expression expression) {
|
| - _rightHandSide = _becomeParentOf(expression);
|
| - }
|
| -
|
| - /**
|
| - * If the AST structure has been resolved, and the function being invoked is
|
| - * known based on static type information, then return the parameter element
|
| - * representing the parameter to which the value of the right operand will be
|
| - * bound. Otherwise, return `null`.
|
| - */
|
| - @deprecated // Use "expression.staticParameterElement"
|
| - ParameterElement get staticParameterElementForRightHandSide {
|
| - return _staticParameterElementForRightHandSide;
|
| - }
|
| -
|
| - /**
|
| - * If the AST structure has been resolved, and the function being invoked is
|
| - * known based on propagated type information, then return the parameter
|
| - * element representing the parameter to which the value of the right operand
|
| - * will be bound. Otherwise, return `null`.
|
| - */
|
| - ParameterElement get _propagatedParameterElementForRightHandSide {
|
| - ExecutableElement executableElement = null;
|
| - if (propagatedElement != null) {
|
| - executableElement = propagatedElement;
|
| - } else {
|
| - if (_leftHandSide is Identifier) {
|
| - Identifier identifier = _leftHandSide as Identifier;
|
| - Element leftElement = identifier.propagatedElement;
|
| - if (leftElement is ExecutableElement) {
|
| - executableElement = leftElement;
|
| - }
|
| - }
|
| - if (_leftHandSide is PropertyAccess) {
|
| - SimpleIdentifier identifier =
|
| - (_leftHandSide as PropertyAccess).propertyName;
|
| - Element leftElement = identifier.propagatedElement;
|
| - if (leftElement is ExecutableElement) {
|
| - executableElement = leftElement;
|
| - }
|
| - }
|
| - }
|
| - if (executableElement == null) {
|
| - return null;
|
| - }
|
| - List<ParameterElement> parameters = executableElement.parameters;
|
| - if (parameters.length < 1) {
|
| - return null;
|
| - }
|
| - return parameters[0];
|
| - }
|
| -
|
| - /**
|
| - * If the AST structure has been resolved, and the function being invoked is
|
| - * known based on static type information, then return the parameter element
|
| - * representing the parameter to which the value of the right operand will be
|
| - * bound. Otherwise, return `null`.
|
| - */
|
| - ParameterElement get _staticParameterElementForRightHandSide {
|
| - ExecutableElement executableElement = null;
|
| - if (staticElement != null) {
|
| - executableElement = staticElement;
|
| - } else {
|
| - if (_leftHandSide is Identifier) {
|
| - Element leftElement = (_leftHandSide as Identifier).staticElement;
|
| - if (leftElement is ExecutableElement) {
|
| - executableElement = leftElement;
|
| - }
|
| - }
|
| - if (_leftHandSide is PropertyAccess) {
|
| - Element leftElement =
|
| - (_leftHandSide as PropertyAccess).propertyName.staticElement;
|
| - if (leftElement is ExecutableElement) {
|
| - executableElement = leftElement;
|
| - }
|
| - }
|
| - }
|
| - if (executableElement == null) {
|
| - return null;
|
| - }
|
| - List<ParameterElement> parameters = executableElement.parameters;
|
| - if (parameters.length < 1) {
|
| - return null;
|
| - }
|
| - return parameters[0];
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitAssignmentExpression(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_leftHandSide, visitor);
|
| - _safelyVisitChild(_rightHandSide, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * An AST visitor that will clone any AST structure that it visits. The cloner
|
| - * will only clone the structure, it will not preserve any resolution results or
|
| - * properties associated with the nodes.
|
| - */
|
| -class AstCloner implements AstVisitor<AstNode> {
|
| - /**
|
| - * A flag indicating whether tokens should be cloned while cloning an AST
|
| - * structure.
|
| - */
|
| - final bool cloneTokens;
|
| -
|
| - /**
|
| - * Initialize a newly created AST cloner to optionally clone tokens while
|
| - * cloning AST nodes if [cloneTokens] is `true`.
|
| - */
|
| - AstCloner(
|
| - [this.cloneTokens = false]); // TODO(brianwilkerson) Change this to be a named parameter.
|
| -
|
| - /**
|
| - * Return a clone of the given [node].
|
| - */
|
| - AstNode cloneNode(AstNode node) {
|
| - if (node == null) {
|
| - return null;
|
| - }
|
| - return node.accept(this) as AstNode;
|
| - }
|
| -
|
| - /**
|
| - * Return a list containing cloned versions of the nodes in the given list of
|
| - * [nodes].
|
| - */
|
| - List<AstNode> cloneNodeList(NodeList nodes) {
|
| - int count = nodes.length;
|
| - List clonedNodes = new List();
|
| - for (int i = 0; i < count; i++) {
|
| - clonedNodes.add((nodes[i]).accept(this) as AstNode);
|
| - }
|
| - return clonedNodes;
|
| - }
|
| -
|
| - /**
|
| - * Clone the given [token] if tokens are supposed to be cloned.
|
| - */
|
| - Token cloneToken(Token token) {
|
| - if (cloneTokens) {
|
| - return (token == null ? null : token.copy());
|
| - } else {
|
| - return token;
|
| - }
|
| - }
|
| -
|
| - /**
|
| - * Clone the given [tokens] if tokens are supposed to be cloned.
|
| - */
|
| - List<Token> cloneTokenList(List<Token> tokens) {
|
| - if (cloneTokens) {
|
| - return tokens.map((Token token) => token.copy()).toList();
|
| - }
|
| - return tokens;
|
| - }
|
| -
|
| - @override
|
| - AdjacentStrings visitAdjacentStrings(AdjacentStrings node) =>
|
| - new AdjacentStrings(cloneNodeList(node.strings));
|
| -
|
| - @override
|
| - Annotation visitAnnotation(Annotation node) => new Annotation(
|
| - cloneToken(node.atSign), cloneNode(node.name), cloneToken(node.period),
|
| - cloneNode(node.constructorName), cloneNode(node.arguments));
|
| -
|
| - @override
|
| - ArgumentList visitArgumentList(ArgumentList node) => new ArgumentList(
|
| - cloneToken(node.leftParenthesis), cloneNodeList(node.arguments),
|
| - cloneToken(node.rightParenthesis));
|
| -
|
| - @override
|
| - AsExpression visitAsExpression(AsExpression node) => new AsExpression(
|
| - cloneNode(node.expression), cloneToken(node.asOperator),
|
| - cloneNode(node.type));
|
| -
|
| - @override
|
| - AstNode visitAssertStatement(AssertStatement node) => new AssertStatement(
|
| - cloneToken(node.assertKeyword), cloneToken(node.leftParenthesis),
|
| - cloneNode(node.condition), cloneToken(node.rightParenthesis),
|
| - cloneToken(node.semicolon));
|
| -
|
| - @override
|
| - AssignmentExpression visitAssignmentExpression(AssignmentExpression node) =>
|
| - new AssignmentExpression(cloneNode(node.leftHandSide),
|
| - cloneToken(node.operator), cloneNode(node.rightHandSide));
|
| -
|
| - @override
|
| - AwaitExpression visitAwaitExpression(AwaitExpression node) =>
|
| - new AwaitExpression(
|
| - cloneToken(node.awaitKeyword), cloneNode(node.expression));
|
| -
|
| - @override
|
| - BinaryExpression visitBinaryExpression(BinaryExpression node) =>
|
| - new BinaryExpression(cloneNode(node.leftOperand),
|
| - cloneToken(node.operator), cloneNode(node.rightOperand));
|
| -
|
| - @override
|
| - Block visitBlock(Block node) => new Block(cloneToken(node.leftBracket),
|
| - cloneNodeList(node.statements), cloneToken(node.rightBracket));
|
| -
|
| - @override
|
| - BlockFunctionBody visitBlockFunctionBody(
|
| - BlockFunctionBody node) => new BlockFunctionBody(
|
| - cloneToken(node.keyword), cloneToken(node.star), cloneNode(node.block));
|
| -
|
| - @override
|
| - BooleanLiteral visitBooleanLiteral(BooleanLiteral node) =>
|
| - new BooleanLiteral(cloneToken(node.literal), node.value);
|
| -
|
| - @override
|
| - BreakStatement visitBreakStatement(BreakStatement node) => new BreakStatement(
|
| - cloneToken(node.breakKeyword), cloneNode(node.label),
|
| - cloneToken(node.semicolon));
|
| -
|
| - @override
|
| - CascadeExpression visitCascadeExpression(CascadeExpression node) =>
|
| - new CascadeExpression(
|
| - cloneNode(node.target), cloneNodeList(node.cascadeSections));
|
| -
|
| - @override
|
| - CatchClause visitCatchClause(CatchClause node) => new CatchClause(
|
| - cloneToken(node.onKeyword), cloneNode(node.exceptionType),
|
| - cloneToken(node.catchKeyword), cloneToken(node.leftParenthesis),
|
| - cloneNode(node.exceptionParameter), cloneToken(node.comma),
|
| - cloneNode(node.stackTraceParameter), cloneToken(node.rightParenthesis),
|
| - cloneNode(node.body));
|
| -
|
| - @override
|
| - ClassDeclaration visitClassDeclaration(ClassDeclaration node) {
|
| - ClassDeclaration copy = new ClassDeclaration(
|
| - cloneNode(node.documentationComment), cloneNodeList(node.metadata),
|
| - cloneToken(node.abstractKeyword), cloneToken(node.classKeyword),
|
| - cloneNode(node.name), cloneNode(node.typeParameters),
|
| - cloneNode(node.extendsClause), cloneNode(node.withClause),
|
| - cloneNode(node.implementsClause), cloneToken(node.leftBracket),
|
| - cloneNodeList(node.members), cloneToken(node.rightBracket));
|
| - copy.nativeClause = cloneNode(node.nativeClause);
|
| - return copy;
|
| - }
|
| -
|
| - @override
|
| - ClassTypeAlias visitClassTypeAlias(ClassTypeAlias node) => new ClassTypeAlias(
|
| - cloneNode(node.documentationComment), cloneNodeList(node.metadata),
|
| - cloneToken(node.typedefKeyword), cloneNode(node.name),
|
| - cloneNode(node.typeParameters), cloneToken(node.equals),
|
| - cloneToken(node.abstractKeyword), cloneNode(node.superclass),
|
| - cloneNode(node.withClause), cloneNode(node.implementsClause),
|
| - cloneToken(node.semicolon));
|
| -
|
| - @override
|
| - Comment visitComment(Comment node) {
|
| - if (node.isDocumentation) {
|
| - return Comment.createDocumentationCommentWithReferences(
|
| - cloneTokenList(node.tokens), cloneNodeList(node.references));
|
| - } else if (node.isBlock) {
|
| - return Comment.createBlockComment(cloneTokenList(node.tokens));
|
| - }
|
| - return Comment.createEndOfLineComment(cloneTokenList(node.tokens));
|
| - }
|
| -
|
| - @override
|
| - CommentReference visitCommentReference(CommentReference node) =>
|
| - new CommentReference(
|
| - cloneToken(node.newKeyword), cloneNode(node.identifier));
|
| -
|
| - @override
|
| - CompilationUnit visitCompilationUnit(CompilationUnit node) {
|
| - CompilationUnit clone = new CompilationUnit(cloneToken(node.beginToken),
|
| - cloneNode(node.scriptTag), cloneNodeList(node.directives),
|
| - cloneNodeList(node.declarations), cloneToken(node.endToken));
|
| - clone.lineInfo = node.lineInfo;
|
| - return clone;
|
| - }
|
| -
|
| - @override
|
| - ConditionalExpression visitConditionalExpression(
|
| - ConditionalExpression node) => new ConditionalExpression(
|
| - cloneNode(node.condition), cloneToken(node.question),
|
| - cloneNode(node.thenExpression), cloneToken(node.colon),
|
| - cloneNode(node.elseExpression));
|
| -
|
| - @override
|
| - ConstructorDeclaration visitConstructorDeclaration(
|
| - ConstructorDeclaration node) => new ConstructorDeclaration(
|
| - cloneNode(node.documentationComment), cloneNodeList(node.metadata),
|
| - cloneToken(node.externalKeyword), cloneToken(node.constKeyword),
|
| - cloneToken(node.factoryKeyword), cloneNode(node.returnType),
|
| - cloneToken(node.period), cloneNode(node.name), cloneNode(node.parameters),
|
| - cloneToken(node.separator), cloneNodeList(node.initializers),
|
| - cloneNode(node.redirectedConstructor), cloneNode(node.body));
|
| -
|
| - @override
|
| - ConstructorFieldInitializer visitConstructorFieldInitializer(
|
| - ConstructorFieldInitializer node) => new ConstructorFieldInitializer(
|
| - cloneToken(node.thisKeyword), cloneToken(node.period),
|
| - cloneNode(node.fieldName), cloneToken(node.equals),
|
| - cloneNode(node.expression));
|
| -
|
| - @override
|
| - ConstructorName visitConstructorName(ConstructorName node) =>
|
| - new ConstructorName(
|
| - cloneNode(node.type), cloneToken(node.period), cloneNode(node.name));
|
| -
|
| - @override
|
| - ContinueStatement visitContinueStatement(ContinueStatement node) =>
|
| - new ContinueStatement(cloneToken(node.continueKeyword),
|
| - cloneNode(node.label), cloneToken(node.semicolon));
|
| -
|
| - @override
|
| - DeclaredIdentifier visitDeclaredIdentifier(DeclaredIdentifier node) =>
|
| - new DeclaredIdentifier(cloneNode(node.documentationComment),
|
| - cloneNodeList(node.metadata), cloneToken(node.keyword),
|
| - cloneNode(node.type), cloneNode(node.identifier));
|
| -
|
| - @override
|
| - DefaultFormalParameter visitDefaultFormalParameter(
|
| - DefaultFormalParameter node) => new DefaultFormalParameter(
|
| - cloneNode(node.parameter), node.kind, cloneToken(node.separator),
|
| - cloneNode(node.defaultValue));
|
| -
|
| - @override
|
| - DoStatement visitDoStatement(DoStatement node) => new DoStatement(
|
| - cloneToken(node.doKeyword), cloneNode(node.body),
|
| - cloneToken(node.whileKeyword), cloneToken(node.leftParenthesis),
|
| - cloneNode(node.condition), cloneToken(node.rightParenthesis),
|
| - cloneToken(node.semicolon));
|
| -
|
| - @override
|
| - DoubleLiteral visitDoubleLiteral(DoubleLiteral node) =>
|
| - new DoubleLiteral(cloneToken(node.literal), node.value);
|
| -
|
| - @override
|
| - EmptyFunctionBody visitEmptyFunctionBody(EmptyFunctionBody node) =>
|
| - new EmptyFunctionBody(cloneToken(node.semicolon));
|
| -
|
| - @override
|
| - EmptyStatement visitEmptyStatement(EmptyStatement node) =>
|
| - new EmptyStatement(cloneToken(node.semicolon));
|
| -
|
| - @override
|
| - AstNode visitEnumConstantDeclaration(EnumConstantDeclaration node) =>
|
| - new EnumConstantDeclaration(cloneNode(node.documentationComment),
|
| - cloneNodeList(node.metadata), cloneNode(node.name));
|
| -
|
| - @override
|
| - EnumDeclaration visitEnumDeclaration(EnumDeclaration node) =>
|
| - new EnumDeclaration(cloneNode(node.documentationComment),
|
| - cloneNodeList(node.metadata), cloneToken(node.enumKeyword),
|
| - cloneNode(node.name), cloneToken(node.leftBracket),
|
| - cloneNodeList(node.constants), cloneToken(node.rightBracket));
|
| -
|
| - @override
|
| - ExportDirective visitExportDirective(ExportDirective node) {
|
| - ExportDirective directive = new ExportDirective(
|
| - cloneNode(node.documentationComment), cloneNodeList(node.metadata),
|
| - cloneToken(node.keyword), cloneNode(node.uri),
|
| - cloneNodeList(node.combinators), cloneToken(node.semicolon));
|
| - directive.source = node.source;
|
| - directive.uriContent = node.uriContent;
|
| - return directive;
|
| - }
|
| -
|
| - @override
|
| - ExpressionFunctionBody visitExpressionFunctionBody(
|
| - ExpressionFunctionBody node) => new ExpressionFunctionBody(
|
| - cloneToken(node.keyword), cloneToken(node.functionDefinition),
|
| - cloneNode(node.expression), cloneToken(node.semicolon));
|
| -
|
| - @override
|
| - ExpressionStatement visitExpressionStatement(ExpressionStatement node) =>
|
| - new ExpressionStatement(
|
| - cloneNode(node.expression), cloneToken(node.semicolon));
|
| -
|
| - @override
|
| - ExtendsClause visitExtendsClause(ExtendsClause node) => new ExtendsClause(
|
| - cloneToken(node.extendsKeyword), cloneNode(node.superclass));
|
| -
|
| - @override
|
| - FieldDeclaration visitFieldDeclaration(FieldDeclaration node) =>
|
| - new FieldDeclaration(cloneNode(node.documentationComment),
|
| - cloneNodeList(node.metadata), cloneToken(node.staticKeyword),
|
| - cloneNode(node.fields), cloneToken(node.semicolon));
|
| -
|
| - @override
|
| - FieldFormalParameter visitFieldFormalParameter(FieldFormalParameter node) =>
|
| - new FieldFormalParameter(cloneNode(node.documentationComment),
|
| - cloneNodeList(node.metadata), cloneToken(node.keyword),
|
| - cloneNode(node.type), cloneToken(node.thisKeyword),
|
| - cloneToken(node.period), cloneNode(node.identifier),
|
| - cloneNode(node.typeParameters), cloneNode(node.parameters));
|
| -
|
| - @override
|
| - ForEachStatement visitForEachStatement(ForEachStatement node) {
|
| - DeclaredIdentifier loopVariable = node.loopVariable;
|
| - if (loopVariable == null) {
|
| - return new ForEachStatement.withReference(cloneToken(node.awaitKeyword),
|
| - cloneToken(node.forKeyword), cloneToken(node.leftParenthesis),
|
| - cloneNode(node.identifier), cloneToken(node.inKeyword),
|
| - cloneNode(node.iterable), cloneToken(node.rightParenthesis),
|
| - cloneNode(node.body));
|
| - }
|
| - return new ForEachStatement.withDeclaration(cloneToken(node.awaitKeyword),
|
| - cloneToken(node.forKeyword), cloneToken(node.leftParenthesis),
|
| - cloneNode(loopVariable), cloneToken(node.inKeyword),
|
| - cloneNode(node.iterable), cloneToken(node.rightParenthesis),
|
| - cloneNode(node.body));
|
| - }
|
| -
|
| - @override
|
| - FormalParameterList visitFormalParameterList(FormalParameterList node) =>
|
| - new FormalParameterList(cloneToken(node.leftParenthesis),
|
| - cloneNodeList(node.parameters), cloneToken(node.leftDelimiter),
|
| - cloneToken(node.rightDelimiter), cloneToken(node.rightParenthesis));
|
| -
|
| - @override
|
| - ForStatement visitForStatement(ForStatement node) => new ForStatement(
|
| - cloneToken(node.forKeyword), cloneToken(node.leftParenthesis),
|
| - cloneNode(node.variables), cloneNode(node.initialization),
|
| - cloneToken(node.leftSeparator), cloneNode(node.condition),
|
| - cloneToken(node.rightSeparator), cloneNodeList(node.updaters),
|
| - cloneToken(node.rightParenthesis), cloneNode(node.body));
|
| -
|
| - @override
|
| - FunctionDeclaration visitFunctionDeclaration(FunctionDeclaration node) =>
|
| - new FunctionDeclaration(cloneNode(node.documentationComment),
|
| - cloneNodeList(node.metadata), cloneToken(node.externalKeyword),
|
| - cloneNode(node.returnType), cloneToken(node.propertyKeyword),
|
| - cloneNode(node.name), cloneNode(node.functionExpression));
|
| -
|
| - @override
|
| - FunctionDeclarationStatement visitFunctionDeclarationStatement(
|
| - FunctionDeclarationStatement node) =>
|
| - new FunctionDeclarationStatement(cloneNode(node.functionDeclaration));
|
| -
|
| - @override
|
| - FunctionExpression visitFunctionExpression(FunctionExpression node) =>
|
| - new FunctionExpression(cloneNode(node.typeParameters),
|
| - cloneNode(node.parameters), cloneNode(node.body));
|
| -
|
| - @override
|
| - FunctionExpressionInvocation visitFunctionExpressionInvocation(
|
| - FunctionExpressionInvocation node) => new FunctionExpressionInvocation(
|
| - cloneNode(node.function), cloneNode(node.typeArguments),
|
| - cloneNode(node.argumentList));
|
| -
|
| - @override
|
| - FunctionTypeAlias visitFunctionTypeAlias(FunctionTypeAlias node) =>
|
| - new FunctionTypeAlias(cloneNode(node.documentationComment),
|
| - cloneNodeList(node.metadata), cloneToken(node.typedefKeyword),
|
| - cloneNode(node.returnType), cloneNode(node.name),
|
| - cloneNode(node.typeParameters), cloneNode(node.parameters),
|
| - cloneToken(node.semicolon));
|
| -
|
| - @override
|
| - FunctionTypedFormalParameter visitFunctionTypedFormalParameter(
|
| - FunctionTypedFormalParameter node) => new FunctionTypedFormalParameter(
|
| - cloneNode(node.documentationComment), cloneNodeList(node.metadata),
|
| - cloneNode(node.returnType), cloneNode(node.identifier),
|
| - cloneNode(node.typeParameters), cloneNode(node.parameters));
|
| -
|
| - @override
|
| - HideCombinator visitHideCombinator(HideCombinator node) => new HideCombinator(
|
| - cloneToken(node.keyword), cloneNodeList(node.hiddenNames));
|
| -
|
| - @override
|
| - IfStatement visitIfStatement(IfStatement node) => new IfStatement(
|
| - cloneToken(node.ifKeyword), cloneToken(node.leftParenthesis),
|
| - cloneNode(node.condition), cloneToken(node.rightParenthesis),
|
| - cloneNode(node.thenStatement), cloneToken(node.elseKeyword),
|
| - cloneNode(node.elseStatement));
|
| -
|
| - @override
|
| - ImplementsClause visitImplementsClause(ImplementsClause node) =>
|
| - new ImplementsClause(
|
| - cloneToken(node.implementsKeyword), cloneNodeList(node.interfaces));
|
| -
|
| - @override
|
| - ImportDirective visitImportDirective(ImportDirective node) {
|
| - ImportDirective directive = new ImportDirective(
|
| - cloneNode(node.documentationComment), cloneNodeList(node.metadata),
|
| - cloneToken(node.keyword), cloneNode(node.uri),
|
| - cloneToken(node.deferredKeyword), cloneToken(node.asKeyword),
|
| - cloneNode(node.prefix), cloneNodeList(node.combinators),
|
| - cloneToken(node.semicolon));
|
| - directive.source = node.source;
|
| - directive.uriContent = node.uriContent;
|
| - return directive;
|
| - }
|
| -
|
| - @override
|
| - IndexExpression visitIndexExpression(IndexExpression node) {
|
| - Token period = node.period;
|
| - if (period == null) {
|
| - return new IndexExpression.forTarget(cloneNode(node.target),
|
| - cloneToken(node.leftBracket), cloneNode(node.index),
|
| - cloneToken(node.rightBracket));
|
| - } else {
|
| - return new IndexExpression.forCascade(cloneToken(period),
|
| - cloneToken(node.leftBracket), cloneNode(node.index),
|
| - cloneToken(node.rightBracket));
|
| - }
|
| - }
|
| -
|
| - @override
|
| - InstanceCreationExpression visitInstanceCreationExpression(
|
| - InstanceCreationExpression node) => new InstanceCreationExpression(
|
| - cloneToken(node.keyword), cloneNode(node.constructorName),
|
| - cloneNode(node.argumentList));
|
| -
|
| - @override
|
| - IntegerLiteral visitIntegerLiteral(IntegerLiteral node) =>
|
| - new IntegerLiteral(cloneToken(node.literal), node.value);
|
| -
|
| - @override
|
| - InterpolationExpression visitInterpolationExpression(
|
| - InterpolationExpression node) => new InterpolationExpression(
|
| - cloneToken(node.leftBracket), cloneNode(node.expression),
|
| - cloneToken(node.rightBracket));
|
| -
|
| - @override
|
| - InterpolationString visitInterpolationString(InterpolationString node) =>
|
| - new InterpolationString(cloneToken(node.contents), node.value);
|
| -
|
| - @override
|
| - IsExpression visitIsExpression(IsExpression node) => new IsExpression(
|
| - cloneNode(node.expression), cloneToken(node.isOperator),
|
| - cloneToken(node.notOperator), cloneNode(node.type));
|
| -
|
| - @override
|
| - Label visitLabel(Label node) =>
|
| - new Label(cloneNode(node.label), cloneToken(node.colon));
|
| -
|
| - @override
|
| - LabeledStatement visitLabeledStatement(LabeledStatement node) =>
|
| - new LabeledStatement(
|
| - cloneNodeList(node.labels), cloneNode(node.statement));
|
| -
|
| - @override
|
| - LibraryDirective visitLibraryDirective(LibraryDirective node) =>
|
| - new LibraryDirective(cloneNode(node.documentationComment),
|
| - cloneNodeList(node.metadata), cloneToken(node.libraryKeyword),
|
| - cloneNode(node.name), cloneToken(node.semicolon));
|
| -
|
| - @override
|
| - LibraryIdentifier visitLibraryIdentifier(LibraryIdentifier node) =>
|
| - new LibraryIdentifier(cloneNodeList(node.components));
|
| -
|
| - @override
|
| - ListLiteral visitListLiteral(ListLiteral node) => new ListLiteral(
|
| - cloneToken(node.constKeyword), cloneNode(node.typeArguments),
|
| - cloneToken(node.leftBracket), cloneNodeList(node.elements),
|
| - cloneToken(node.rightBracket));
|
| -
|
| - @override
|
| - MapLiteral visitMapLiteral(MapLiteral node) => new MapLiteral(
|
| - cloneToken(node.constKeyword), cloneNode(node.typeArguments),
|
| - cloneToken(node.leftBracket), cloneNodeList(node.entries),
|
| - cloneToken(node.rightBracket));
|
| -
|
| - @override
|
| - MapLiteralEntry visitMapLiteralEntry(
|
| - MapLiteralEntry node) => new MapLiteralEntry(
|
| - cloneNode(node.key), cloneToken(node.separator), cloneNode(node.value));
|
| -
|
| - @override
|
| - MethodDeclaration visitMethodDeclaration(MethodDeclaration node) =>
|
| - new MethodDeclaration(cloneNode(node.documentationComment),
|
| - cloneNodeList(node.metadata), cloneToken(node.externalKeyword),
|
| - cloneToken(node.modifierKeyword), cloneNode(node.returnType),
|
| - cloneToken(node.propertyKeyword), cloneToken(node.operatorKeyword),
|
| - cloneNode(node.name), cloneNode(node.typeParameters),
|
| - cloneNode(node.parameters), cloneNode(node.body));
|
| -
|
| - @override
|
| - MethodInvocation visitMethodInvocation(MethodInvocation node) =>
|
| - new MethodInvocation(cloneNode(node.target), cloneToken(node.operator),
|
| - cloneNode(node.methodName), cloneNode(node.typeArguments),
|
| - cloneNode(node.argumentList));
|
| -
|
| - @override
|
| - NamedExpression visitNamedExpression(NamedExpression node) =>
|
| - new NamedExpression(cloneNode(node.name), cloneNode(node.expression));
|
| -
|
| - @override
|
| - AstNode visitNativeClause(NativeClause node) =>
|
| - new NativeClause(cloneToken(node.nativeKeyword), cloneNode(node.name));
|
| -
|
| - @override
|
| - NativeFunctionBody visitNativeFunctionBody(NativeFunctionBody node) =>
|
| - new NativeFunctionBody(cloneToken(node.nativeKeyword),
|
| - cloneNode(node.stringLiteral), cloneToken(node.semicolon));
|
| -
|
| - @override
|
| - NullLiteral visitNullLiteral(NullLiteral node) =>
|
| - new NullLiteral(cloneToken(node.literal));
|
| -
|
| - @override
|
| - ParenthesizedExpression visitParenthesizedExpression(
|
| - ParenthesizedExpression node) => new ParenthesizedExpression(
|
| - cloneToken(node.leftParenthesis), cloneNode(node.expression),
|
| - cloneToken(node.rightParenthesis));
|
| -
|
| - @override
|
| - PartDirective visitPartDirective(PartDirective node) {
|
| - PartDirective directive = new PartDirective(
|
| - cloneNode(node.documentationComment), cloneNodeList(node.metadata),
|
| - cloneToken(node.partKeyword), cloneNode(node.uri),
|
| - cloneToken(node.semicolon));
|
| - directive.source = node.source;
|
| - directive.uriContent = node.uriContent;
|
| - return directive;
|
| - }
|
| -
|
| - @override
|
| - PartOfDirective visitPartOfDirective(PartOfDirective node) =>
|
| - new PartOfDirective(cloneNode(node.documentationComment),
|
| - cloneNodeList(node.metadata), cloneToken(node.partKeyword),
|
| - cloneToken(node.ofKeyword), cloneNode(node.libraryName),
|
| - cloneToken(node.semicolon));
|
| -
|
| - @override
|
| - PostfixExpression visitPostfixExpression(PostfixExpression node) =>
|
| - new PostfixExpression(cloneNode(node.operand), cloneToken(node.operator));
|
| -
|
| - @override
|
| - PrefixedIdentifier visitPrefixedIdentifier(PrefixedIdentifier node) =>
|
| - new PrefixedIdentifier(cloneNode(node.prefix), cloneToken(node.period),
|
| - cloneNode(node.identifier));
|
| -
|
| - @override
|
| - PrefixExpression visitPrefixExpression(PrefixExpression node) =>
|
| - new PrefixExpression(cloneToken(node.operator), cloneNode(node.operand));
|
| -
|
| - @override
|
| - PropertyAccess visitPropertyAccess(PropertyAccess node) => new PropertyAccess(
|
| - cloneNode(node.target), cloneToken(node.operator),
|
| - cloneNode(node.propertyName));
|
| -
|
| - @override
|
| - RedirectingConstructorInvocation visitRedirectingConstructorInvocation(
|
| - RedirectingConstructorInvocation node) =>
|
| - new RedirectingConstructorInvocation(cloneToken(node.thisKeyword),
|
| - cloneToken(node.period), cloneNode(node.constructorName),
|
| - cloneNode(node.argumentList));
|
| -
|
| - @override
|
| - RethrowExpression visitRethrowExpression(RethrowExpression node) =>
|
| - new RethrowExpression(cloneToken(node.rethrowKeyword));
|
| -
|
| - @override
|
| - ReturnStatement visitReturnStatement(ReturnStatement node) =>
|
| - new ReturnStatement(cloneToken(node.returnKeyword),
|
| - cloneNode(node.expression), cloneToken(node.semicolon));
|
| -
|
| - @override
|
| - ScriptTag visitScriptTag(ScriptTag node) =>
|
| - new ScriptTag(cloneToken(node.scriptTag));
|
| -
|
| - @override
|
| - ShowCombinator visitShowCombinator(ShowCombinator node) => new ShowCombinator(
|
| - cloneToken(node.keyword), cloneNodeList(node.shownNames));
|
| -
|
| - @override
|
| - SimpleFormalParameter visitSimpleFormalParameter(
|
| - SimpleFormalParameter node) => new SimpleFormalParameter(
|
| - cloneNode(node.documentationComment), cloneNodeList(node.metadata),
|
| - cloneToken(node.keyword), cloneNode(node.type),
|
| - cloneNode(node.identifier));
|
| -
|
| - @override
|
| - SimpleIdentifier visitSimpleIdentifier(SimpleIdentifier node) =>
|
| - new SimpleIdentifier(cloneToken(node.token));
|
| -
|
| - @override
|
| - SimpleStringLiteral visitSimpleStringLiteral(SimpleStringLiteral node) =>
|
| - new SimpleStringLiteral(cloneToken(node.literal), node.value);
|
| -
|
| - @override
|
| - StringInterpolation visitStringInterpolation(StringInterpolation node) =>
|
| - new StringInterpolation(cloneNodeList(node.elements));
|
| -
|
| - @override
|
| - SuperConstructorInvocation visitSuperConstructorInvocation(
|
| - SuperConstructorInvocation node) => new SuperConstructorInvocation(
|
| - cloneToken(node.superKeyword), cloneToken(node.period),
|
| - cloneNode(node.constructorName), cloneNode(node.argumentList));
|
| -
|
| - @override
|
| - SuperExpression visitSuperExpression(SuperExpression node) =>
|
| - new SuperExpression(cloneToken(node.superKeyword));
|
| -
|
| - @override
|
| - SwitchCase visitSwitchCase(SwitchCase node) => new SwitchCase(
|
| - cloneNodeList(node.labels), cloneToken(node.keyword),
|
| - cloneNode(node.expression), cloneToken(node.colon),
|
| - cloneNodeList(node.statements));
|
| -
|
| - @override
|
| - SwitchDefault visitSwitchDefault(SwitchDefault node) => new SwitchDefault(
|
| - cloneNodeList(node.labels), cloneToken(node.keyword),
|
| - cloneToken(node.colon), cloneNodeList(node.statements));
|
| -
|
| - @override
|
| - SwitchStatement visitSwitchStatement(SwitchStatement node) =>
|
| - new SwitchStatement(cloneToken(node.switchKeyword),
|
| - cloneToken(node.leftParenthesis), cloneNode(node.expression),
|
| - cloneToken(node.rightParenthesis), cloneToken(node.leftBracket),
|
| - cloneNodeList(node.members), cloneToken(node.rightBracket));
|
| -
|
| - @override
|
| - SymbolLiteral visitSymbolLiteral(SymbolLiteral node) => new SymbolLiteral(
|
| - cloneToken(node.poundSign), cloneTokenList(node.components));
|
| -
|
| - @override
|
| - ThisExpression visitThisExpression(ThisExpression node) =>
|
| - new ThisExpression(cloneToken(node.thisKeyword));
|
| -
|
| - @override
|
| - ThrowExpression visitThrowExpression(ThrowExpression node) =>
|
| - new ThrowExpression(
|
| - cloneToken(node.throwKeyword), cloneNode(node.expression));
|
| -
|
| - @override
|
| - TopLevelVariableDeclaration visitTopLevelVariableDeclaration(
|
| - TopLevelVariableDeclaration node) => new TopLevelVariableDeclaration(
|
| - cloneNode(node.documentationComment), cloneNodeList(node.metadata),
|
| - cloneNode(node.variables), cloneToken(node.semicolon));
|
| -
|
| - @override
|
| - TryStatement visitTryStatement(TryStatement node) => new TryStatement(
|
| - cloneToken(node.tryKeyword), cloneNode(node.body),
|
| - cloneNodeList(node.catchClauses), cloneToken(node.finallyKeyword),
|
| - cloneNode(node.finallyBlock));
|
| -
|
| - @override
|
| - TypeArgumentList visitTypeArgumentList(TypeArgumentList node) =>
|
| - new TypeArgumentList(cloneToken(node.leftBracket),
|
| - cloneNodeList(node.arguments), cloneToken(node.rightBracket));
|
| -
|
| - @override
|
| - TypeName visitTypeName(TypeName node) =>
|
| - new TypeName(cloneNode(node.name), cloneNode(node.typeArguments));
|
| -
|
| - @override
|
| - TypeParameter visitTypeParameter(TypeParameter node) => new TypeParameter(
|
| - cloneNode(node.documentationComment), cloneNodeList(node.metadata),
|
| - cloneNode(node.name), cloneToken(node.extendsKeyword),
|
| - cloneNode(node.bound));
|
| -
|
| - @override
|
| - TypeParameterList visitTypeParameterList(TypeParameterList node) =>
|
| - new TypeParameterList(cloneToken(node.leftBracket),
|
| - cloneNodeList(node.typeParameters), cloneToken(node.rightBracket));
|
| -
|
| - @override
|
| - VariableDeclaration visitVariableDeclaration(VariableDeclaration node) =>
|
| - new VariableDeclaration(cloneNode(node.name), cloneToken(node.equals),
|
| - cloneNode(node.initializer));
|
| -
|
| - @override
|
| - VariableDeclarationList visitVariableDeclarationList(
|
| - VariableDeclarationList node) => new VariableDeclarationList(null,
|
| - cloneNodeList(node.metadata), cloneToken(node.keyword),
|
| - cloneNode(node.type), cloneNodeList(node.variables));
|
| -
|
| - @override
|
| - VariableDeclarationStatement visitVariableDeclarationStatement(
|
| - VariableDeclarationStatement node) => new VariableDeclarationStatement(
|
| - cloneNode(node.variables), cloneToken(node.semicolon));
|
| -
|
| - @override
|
| - WhileStatement visitWhileStatement(WhileStatement node) => new WhileStatement(
|
| - cloneToken(node.whileKeyword), cloneToken(node.leftParenthesis),
|
| - cloneNode(node.condition), cloneToken(node.rightParenthesis),
|
| - cloneNode(node.body));
|
| -
|
| - @override
|
| - WithClause visitWithClause(WithClause node) => new WithClause(
|
| - cloneToken(node.withKeyword), cloneNodeList(node.mixinTypes));
|
| -
|
| - @override
|
| - YieldStatement visitYieldStatement(YieldStatement node) => new YieldStatement(
|
| - cloneToken(node.yieldKeyword), cloneToken(node.star),
|
| - cloneNode(node.expression), cloneToken(node.semicolon));
|
| -
|
| - /**
|
| - * Return a clone of the given [node].
|
| - */
|
| - static AstNode clone(AstNode node) {
|
| - return node.accept(new AstCloner());
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * An AstVisitor that compares the structure of two AstNodes to see whether they
|
| - * are equal.
|
| - */
|
| -class AstComparator implements AstVisitor<bool> {
|
| - /**
|
| - * The AST node with which the node being visited is to be compared. This is
|
| - * only valid at the beginning of each visit method (until [isEqualNodes] is
|
| - * invoked).
|
| - */
|
| - AstNode _other;
|
| -
|
| - /**
|
| - * Return `true` if the [first] node and the [second] node have the same
|
| - * structure.
|
| - *
|
| - * *Note:* This method is only visible for testing purposes and should not be
|
| - * used by clients.
|
| - */
|
| - bool isEqualNodes(AstNode first, AstNode second) {
|
| - if (first == null) {
|
| - return second == null;
|
| - } else if (second == null) {
|
| - return false;
|
| - } else if (first.runtimeType != second.runtimeType) {
|
| - return false;
|
| - }
|
| - _other = second;
|
| - return first.accept(this);
|
| - }
|
| -
|
| - /**
|
| - * Return `true` if the [first] token and the [second] token have the same
|
| - * structure.
|
| - *
|
| - * *Note:* This method is only visible for testing purposes and should not be
|
| - * used by clients.
|
| - */
|
| - bool isEqualTokens(Token first, Token second) {
|
| - if (first == null) {
|
| - return second == null;
|
| - } else if (second == null) {
|
| - return false;
|
| - } else if (identical(first, second)) {
|
| - return true;
|
| - }
|
| - return first.offset == second.offset &&
|
| - first.length == second.length &&
|
| - first.lexeme == second.lexeme;
|
| - }
|
| -
|
| - @override
|
| - bool visitAdjacentStrings(AdjacentStrings node) {
|
| - AdjacentStrings other = _other as AdjacentStrings;
|
| - return _isEqualNodeLists(node.strings, other.strings);
|
| - }
|
| -
|
| - @override
|
| - bool visitAnnotation(Annotation node) {
|
| - Annotation other = _other as Annotation;
|
| - return isEqualTokens(node.atSign, other.atSign) &&
|
| - isEqualNodes(node.name, other.name) &&
|
| - isEqualTokens(node.period, other.period) &&
|
| - isEqualNodes(node.constructorName, other.constructorName) &&
|
| - isEqualNodes(node.arguments, other.arguments);
|
| - }
|
| -
|
| - @override
|
| - bool visitArgumentList(ArgumentList node) {
|
| - ArgumentList other = _other as ArgumentList;
|
| - return isEqualTokens(node.leftParenthesis, other.leftParenthesis) &&
|
| - _isEqualNodeLists(node.arguments, other.arguments) &&
|
| - isEqualTokens(node.rightParenthesis, other.rightParenthesis);
|
| - }
|
| -
|
| - @override
|
| - bool visitAsExpression(AsExpression node) {
|
| - AsExpression other = _other as AsExpression;
|
| - return isEqualNodes(node.expression, other.expression) &&
|
| - isEqualTokens(node.asOperator, other.asOperator) &&
|
| - isEqualNodes(node.type, other.type);
|
| - }
|
| -
|
| - @override
|
| - bool visitAssertStatement(AssertStatement node) {
|
| - AssertStatement other = _other as AssertStatement;
|
| - return isEqualTokens(node.assertKeyword, other.assertKeyword) &&
|
| - isEqualTokens(node.leftParenthesis, other.leftParenthesis) &&
|
| - isEqualNodes(node.condition, other.condition) &&
|
| - isEqualTokens(node.rightParenthesis, other.rightParenthesis) &&
|
| - isEqualTokens(node.semicolon, other.semicolon);
|
| - }
|
| -
|
| - @override
|
| - bool visitAssignmentExpression(AssignmentExpression node) {
|
| - AssignmentExpression other = _other as AssignmentExpression;
|
| - return isEqualNodes(node.leftHandSide, other.leftHandSide) &&
|
| - isEqualTokens(node.operator, other.operator) &&
|
| - isEqualNodes(node.rightHandSide, other.rightHandSide);
|
| - }
|
| -
|
| - @override
|
| - bool visitAwaitExpression(AwaitExpression node) {
|
| - AwaitExpression other = _other as AwaitExpression;
|
| - return isEqualTokens(node.awaitKeyword, other.awaitKeyword) &&
|
| - isEqualNodes(node.expression, other.expression);
|
| - }
|
| -
|
| - @override
|
| - bool visitBinaryExpression(BinaryExpression node) {
|
| - BinaryExpression other = _other as BinaryExpression;
|
| - return isEqualNodes(node.leftOperand, other.leftOperand) &&
|
| - isEqualTokens(node.operator, other.operator) &&
|
| - isEqualNodes(node.rightOperand, other.rightOperand);
|
| - }
|
| -
|
| - @override
|
| - bool visitBlock(Block node) {
|
| - Block other = _other as Block;
|
| - return isEqualTokens(node.leftBracket, other.leftBracket) &&
|
| - _isEqualNodeLists(node.statements, other.statements) &&
|
| - isEqualTokens(node.rightBracket, other.rightBracket);
|
| - }
|
| -
|
| - @override
|
| - bool visitBlockFunctionBody(BlockFunctionBody node) {
|
| - BlockFunctionBody other = _other as BlockFunctionBody;
|
| - return isEqualNodes(node.block, other.block);
|
| - }
|
| -
|
| - @override
|
| - bool visitBooleanLiteral(BooleanLiteral node) {
|
| - BooleanLiteral other = _other as BooleanLiteral;
|
| - return isEqualTokens(node.literal, other.literal) &&
|
| - node.value == other.value;
|
| - }
|
| -
|
| - @override
|
| - bool visitBreakStatement(BreakStatement node) {
|
| - BreakStatement other = _other as BreakStatement;
|
| - return isEqualTokens(node.breakKeyword, other.breakKeyword) &&
|
| - isEqualNodes(node.label, other.label) &&
|
| - isEqualTokens(node.semicolon, other.semicolon);
|
| - }
|
| -
|
| - @override
|
| - bool visitCascadeExpression(CascadeExpression node) {
|
| - CascadeExpression other = _other as CascadeExpression;
|
| - return isEqualNodes(node.target, other.target) &&
|
| - _isEqualNodeLists(node.cascadeSections, other.cascadeSections);
|
| - }
|
| -
|
| - @override
|
| - bool visitCatchClause(CatchClause node) {
|
| - CatchClause other = _other as CatchClause;
|
| - return isEqualTokens(node.onKeyword, other.onKeyword) &&
|
| - isEqualNodes(node.exceptionType, other.exceptionType) &&
|
| - isEqualTokens(node.catchKeyword, other.catchKeyword) &&
|
| - isEqualTokens(node.leftParenthesis, other.leftParenthesis) &&
|
| - isEqualNodes(node.exceptionParameter, other.exceptionParameter) &&
|
| - isEqualTokens(node.comma, other.comma) &&
|
| - isEqualNodes(node.stackTraceParameter, other.stackTraceParameter) &&
|
| - isEqualTokens(node.rightParenthesis, other.rightParenthesis) &&
|
| - isEqualNodes(node.body, other.body);
|
| - }
|
| -
|
| - @override
|
| - bool visitClassDeclaration(ClassDeclaration node) {
|
| - ClassDeclaration other = _other as ClassDeclaration;
|
| - return isEqualNodes(
|
| - node.documentationComment, other.documentationComment) &&
|
| - _isEqualNodeLists(node.metadata, other.metadata) &&
|
| - isEqualTokens(node.abstractKeyword, other.abstractKeyword) &&
|
| - isEqualTokens(node.classKeyword, other.classKeyword) &&
|
| - isEqualNodes(node.name, other.name) &&
|
| - isEqualNodes(node.typeParameters, other.typeParameters) &&
|
| - isEqualNodes(node.extendsClause, other.extendsClause) &&
|
| - isEqualNodes(node.withClause, other.withClause) &&
|
| - isEqualNodes(node.implementsClause, other.implementsClause) &&
|
| - isEqualTokens(node.leftBracket, other.leftBracket) &&
|
| - _isEqualNodeLists(node.members, other.members) &&
|
| - isEqualTokens(node.rightBracket, other.rightBracket);
|
| - }
|
| -
|
| - @override
|
| - bool visitClassTypeAlias(ClassTypeAlias node) {
|
| - ClassTypeAlias other = _other as ClassTypeAlias;
|
| - return isEqualNodes(
|
| - node.documentationComment, other.documentationComment) &&
|
| - _isEqualNodeLists(node.metadata, other.metadata) &&
|
| - isEqualTokens(node.typedefKeyword, other.typedefKeyword) &&
|
| - isEqualNodes(node.name, other.name) &&
|
| - isEqualNodes(node.typeParameters, other.typeParameters) &&
|
| - isEqualTokens(node.equals, other.equals) &&
|
| - isEqualTokens(node.abstractKeyword, other.abstractKeyword) &&
|
| - isEqualNodes(node.superclass, other.superclass) &&
|
| - isEqualNodes(node.withClause, other.withClause) &&
|
| - isEqualNodes(node.implementsClause, other.implementsClause) &&
|
| - isEqualTokens(node.semicolon, other.semicolon);
|
| - }
|
| -
|
| - @override
|
| - bool visitComment(Comment node) {
|
| - Comment other = _other as Comment;
|
| - return _isEqualNodeLists(node.references, other.references);
|
| - }
|
| -
|
| - @override
|
| - bool visitCommentReference(CommentReference node) {
|
| - CommentReference other = _other as CommentReference;
|
| - return isEqualTokens(node.newKeyword, other.newKeyword) &&
|
| - isEqualNodes(node.identifier, other.identifier);
|
| - }
|
| -
|
| - @override
|
| - bool visitCompilationUnit(CompilationUnit node) {
|
| - CompilationUnit other = _other as CompilationUnit;
|
| - return isEqualTokens(node.beginToken, other.beginToken) &&
|
| - isEqualNodes(node.scriptTag, other.scriptTag) &&
|
| - _isEqualNodeLists(node.directives, other.directives) &&
|
| - _isEqualNodeLists(node.declarations, other.declarations) &&
|
| - isEqualTokens(node.endToken, other.endToken);
|
| - }
|
| -
|
| - @override
|
| - bool visitConditionalExpression(ConditionalExpression node) {
|
| - ConditionalExpression other = _other as ConditionalExpression;
|
| - return isEqualNodes(node.condition, other.condition) &&
|
| - isEqualTokens(node.question, other.question) &&
|
| - isEqualNodes(node.thenExpression, other.thenExpression) &&
|
| - isEqualTokens(node.colon, other.colon) &&
|
| - isEqualNodes(node.elseExpression, other.elseExpression);
|
| - }
|
| -
|
| - @override
|
| - bool visitConstructorDeclaration(ConstructorDeclaration node) {
|
| - ConstructorDeclaration other = _other as ConstructorDeclaration;
|
| - return isEqualNodes(
|
| - node.documentationComment, other.documentationComment) &&
|
| - _isEqualNodeLists(node.metadata, other.metadata) &&
|
| - isEqualTokens(node.externalKeyword, other.externalKeyword) &&
|
| - isEqualTokens(node.constKeyword, other.constKeyword) &&
|
| - isEqualTokens(node.factoryKeyword, other.factoryKeyword) &&
|
| - isEqualNodes(node.returnType, other.returnType) &&
|
| - isEqualTokens(node.period, other.period) &&
|
| - isEqualNodes(node.name, other.name) &&
|
| - isEqualNodes(node.parameters, other.parameters) &&
|
| - isEqualTokens(node.separator, other.separator) &&
|
| - _isEqualNodeLists(node.initializers, other.initializers) &&
|
| - isEqualNodes(node.redirectedConstructor, other.redirectedConstructor) &&
|
| - isEqualNodes(node.body, other.body);
|
| - }
|
| -
|
| - @override
|
| - bool visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
|
| - ConstructorFieldInitializer other = _other as ConstructorFieldInitializer;
|
| - return isEqualTokens(node.thisKeyword, other.thisKeyword) &&
|
| - isEqualTokens(node.period, other.period) &&
|
| - isEqualNodes(node.fieldName, other.fieldName) &&
|
| - isEqualTokens(node.equals, other.equals) &&
|
| - isEqualNodes(node.expression, other.expression);
|
| - }
|
| -
|
| - @override
|
| - bool visitConstructorName(ConstructorName node) {
|
| - ConstructorName other = _other as ConstructorName;
|
| - return isEqualNodes(node.type, other.type) &&
|
| - isEqualTokens(node.period, other.period) &&
|
| - isEqualNodes(node.name, other.name);
|
| - }
|
| -
|
| - @override
|
| - bool visitContinueStatement(ContinueStatement node) {
|
| - ContinueStatement other = _other as ContinueStatement;
|
| - return isEqualTokens(node.continueKeyword, other.continueKeyword) &&
|
| - isEqualNodes(node.label, other.label) &&
|
| - isEqualTokens(node.semicolon, other.semicolon);
|
| - }
|
| -
|
| - @override
|
| - bool visitDeclaredIdentifier(DeclaredIdentifier node) {
|
| - DeclaredIdentifier other = _other as DeclaredIdentifier;
|
| - return isEqualNodes(
|
| - node.documentationComment, other.documentationComment) &&
|
| - _isEqualNodeLists(node.metadata, other.metadata) &&
|
| - isEqualTokens(node.keyword, other.keyword) &&
|
| - isEqualNodes(node.type, other.type) &&
|
| - isEqualNodes(node.identifier, other.identifier);
|
| - }
|
| -
|
| - @override
|
| - bool visitDefaultFormalParameter(DefaultFormalParameter node) {
|
| - DefaultFormalParameter other = _other as DefaultFormalParameter;
|
| - return isEqualNodes(node.parameter, other.parameter) &&
|
| - node.kind == other.kind &&
|
| - isEqualTokens(node.separator, other.separator) &&
|
| - isEqualNodes(node.defaultValue, other.defaultValue);
|
| - }
|
| -
|
| - @override
|
| - bool visitDoStatement(DoStatement node) {
|
| - DoStatement other = _other as DoStatement;
|
| - return isEqualTokens(node.doKeyword, other.doKeyword) &&
|
| - isEqualNodes(node.body, other.body) &&
|
| - isEqualTokens(node.whileKeyword, other.whileKeyword) &&
|
| - isEqualTokens(node.leftParenthesis, other.leftParenthesis) &&
|
| - isEqualNodes(node.condition, other.condition) &&
|
| - isEqualTokens(node.rightParenthesis, other.rightParenthesis) &&
|
| - isEqualTokens(node.semicolon, other.semicolon);
|
| - }
|
| -
|
| - @override
|
| - bool visitDoubleLiteral(DoubleLiteral node) {
|
| - DoubleLiteral other = _other as DoubleLiteral;
|
| - return isEqualTokens(node.literal, other.literal) &&
|
| - node.value == other.value;
|
| - }
|
| -
|
| - @override
|
| - bool visitEmptyFunctionBody(EmptyFunctionBody node) {
|
| - EmptyFunctionBody other = _other as EmptyFunctionBody;
|
| - return isEqualTokens(node.semicolon, other.semicolon);
|
| - }
|
| -
|
| - @override
|
| - bool visitEmptyStatement(EmptyStatement node) {
|
| - EmptyStatement other = _other as EmptyStatement;
|
| - return isEqualTokens(node.semicolon, other.semicolon);
|
| - }
|
| -
|
| - @override
|
| - bool visitEnumConstantDeclaration(EnumConstantDeclaration node) {
|
| - EnumConstantDeclaration other = _other as EnumConstantDeclaration;
|
| - return isEqualNodes(
|
| - node.documentationComment, other.documentationComment) &&
|
| - _isEqualNodeLists(node.metadata, other.metadata) &&
|
| - isEqualNodes(node.name, other.name);
|
| - }
|
| -
|
| - @override
|
| - bool visitEnumDeclaration(EnumDeclaration node) {
|
| - EnumDeclaration other = _other as EnumDeclaration;
|
| - return isEqualNodes(
|
| - node.documentationComment, other.documentationComment) &&
|
| - _isEqualNodeLists(node.metadata, other.metadata) &&
|
| - isEqualTokens(node.enumKeyword, other.enumKeyword) &&
|
| - isEqualNodes(node.name, other.name) &&
|
| - isEqualTokens(node.leftBracket, other.leftBracket) &&
|
| - _isEqualNodeLists(node.constants, other.constants) &&
|
| - isEqualTokens(node.rightBracket, other.rightBracket);
|
| - }
|
| -
|
| - @override
|
| - bool visitExportDirective(ExportDirective node) {
|
| - ExportDirective other = _other as ExportDirective;
|
| - return isEqualNodes(
|
| - node.documentationComment, other.documentationComment) &&
|
| - _isEqualNodeLists(node.metadata, other.metadata) &&
|
| - isEqualTokens(node.keyword, other.keyword) &&
|
| - isEqualNodes(node.uri, other.uri) &&
|
| - _isEqualNodeLists(node.combinators, other.combinators) &&
|
| - isEqualTokens(node.semicolon, other.semicolon);
|
| - }
|
| -
|
| - @override
|
| - bool visitExpressionFunctionBody(ExpressionFunctionBody node) {
|
| - ExpressionFunctionBody other = _other as ExpressionFunctionBody;
|
| - return isEqualTokens(node.functionDefinition, other.functionDefinition) &&
|
| - isEqualNodes(node.expression, other.expression) &&
|
| - isEqualTokens(node.semicolon, other.semicolon);
|
| - }
|
| -
|
| - @override
|
| - bool visitExpressionStatement(ExpressionStatement node) {
|
| - ExpressionStatement other = _other as ExpressionStatement;
|
| - return isEqualNodes(node.expression, other.expression) &&
|
| - isEqualTokens(node.semicolon, other.semicolon);
|
| - }
|
| -
|
| - @override
|
| - bool visitExtendsClause(ExtendsClause node) {
|
| - ExtendsClause other = _other as ExtendsClause;
|
| - return isEqualTokens(node.extendsKeyword, other.extendsKeyword) &&
|
| - isEqualNodes(node.superclass, other.superclass);
|
| - }
|
| -
|
| - @override
|
| - bool visitFieldDeclaration(FieldDeclaration node) {
|
| - FieldDeclaration other = _other as FieldDeclaration;
|
| - return isEqualNodes(
|
| - node.documentationComment, other.documentationComment) &&
|
| - _isEqualNodeLists(node.metadata, other.metadata) &&
|
| - isEqualTokens(node.staticKeyword, other.staticKeyword) &&
|
| - isEqualNodes(node.fields, other.fields) &&
|
| - isEqualTokens(node.semicolon, other.semicolon);
|
| - }
|
| -
|
| - @override
|
| - bool visitFieldFormalParameter(FieldFormalParameter node) {
|
| - FieldFormalParameter other = _other as FieldFormalParameter;
|
| - return isEqualNodes(
|
| - node.documentationComment, other.documentationComment) &&
|
| - _isEqualNodeLists(node.metadata, other.metadata) &&
|
| - isEqualTokens(node.keyword, other.keyword) &&
|
| - isEqualNodes(node.type, other.type) &&
|
| - isEqualTokens(node.thisKeyword, other.thisKeyword) &&
|
| - isEqualTokens(node.period, other.period) &&
|
| - isEqualNodes(node.identifier, other.identifier);
|
| - }
|
| -
|
| - @override
|
| - bool visitForEachStatement(ForEachStatement node) {
|
| - ForEachStatement other = _other as ForEachStatement;
|
| - return isEqualTokens(node.forKeyword, other.forKeyword) &&
|
| - isEqualTokens(node.leftParenthesis, other.leftParenthesis) &&
|
| - isEqualNodes(node.loopVariable, other.loopVariable) &&
|
| - isEqualTokens(node.inKeyword, other.inKeyword) &&
|
| - isEqualNodes(node.iterable, other.iterable) &&
|
| - isEqualTokens(node.rightParenthesis, other.rightParenthesis) &&
|
| - isEqualNodes(node.body, other.body);
|
| - }
|
| -
|
| - @override
|
| - bool visitFormalParameterList(FormalParameterList node) {
|
| - FormalParameterList other = _other as FormalParameterList;
|
| - return isEqualTokens(node.leftParenthesis, other.leftParenthesis) &&
|
| - _isEqualNodeLists(node.parameters, other.parameters) &&
|
| - isEqualTokens(node.leftDelimiter, other.leftDelimiter) &&
|
| - isEqualTokens(node.rightDelimiter, other.rightDelimiter) &&
|
| - isEqualTokens(node.rightParenthesis, other.rightParenthesis);
|
| - }
|
| -
|
| - @override
|
| - bool visitForStatement(ForStatement node) {
|
| - ForStatement other = _other as ForStatement;
|
| - return isEqualTokens(node.forKeyword, other.forKeyword) &&
|
| - isEqualTokens(node.leftParenthesis, other.leftParenthesis) &&
|
| - isEqualNodes(node.variables, other.variables) &&
|
| - isEqualNodes(node.initialization, other.initialization) &&
|
| - isEqualTokens(node.leftSeparator, other.leftSeparator) &&
|
| - isEqualNodes(node.condition, other.condition) &&
|
| - isEqualTokens(node.rightSeparator, other.rightSeparator) &&
|
| - _isEqualNodeLists(node.updaters, other.updaters) &&
|
| - isEqualTokens(node.rightParenthesis, other.rightParenthesis) &&
|
| - isEqualNodes(node.body, other.body);
|
| - }
|
| -
|
| - @override
|
| - bool visitFunctionDeclaration(FunctionDeclaration node) {
|
| - FunctionDeclaration other = _other as FunctionDeclaration;
|
| - return isEqualNodes(
|
| - node.documentationComment, other.documentationComment) &&
|
| - _isEqualNodeLists(node.metadata, other.metadata) &&
|
| - isEqualTokens(node.externalKeyword, other.externalKeyword) &&
|
| - isEqualNodes(node.returnType, other.returnType) &&
|
| - isEqualTokens(node.propertyKeyword, other.propertyKeyword) &&
|
| - isEqualNodes(node.name, other.name) &&
|
| - isEqualNodes(node.functionExpression, other.functionExpression);
|
| - }
|
| -
|
| - @override
|
| - bool visitFunctionDeclarationStatement(FunctionDeclarationStatement node) {
|
| - FunctionDeclarationStatement other = _other as FunctionDeclarationStatement;
|
| - return isEqualNodes(node.functionDeclaration, other.functionDeclaration);
|
| - }
|
| -
|
| - @override
|
| - bool visitFunctionExpression(FunctionExpression node) {
|
| - FunctionExpression other = _other as FunctionExpression;
|
| - return isEqualNodes(node.parameters, other.parameters) &&
|
| - isEqualNodes(node.body, other.body);
|
| - }
|
| -
|
| - @override
|
| - bool visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
|
| - FunctionExpressionInvocation other = _other as FunctionExpressionInvocation;
|
| - return isEqualNodes(node.function, other.function) &&
|
| - isEqualNodes(node.argumentList, other.argumentList);
|
| - }
|
| -
|
| - @override
|
| - bool visitFunctionTypeAlias(FunctionTypeAlias node) {
|
| - FunctionTypeAlias other = _other as FunctionTypeAlias;
|
| - return isEqualNodes(
|
| - node.documentationComment, other.documentationComment) &&
|
| - _isEqualNodeLists(node.metadata, other.metadata) &&
|
| - isEqualTokens(node.typedefKeyword, other.typedefKeyword) &&
|
| - isEqualNodes(node.returnType, other.returnType) &&
|
| - isEqualNodes(node.name, other.name) &&
|
| - isEqualNodes(node.typeParameters, other.typeParameters) &&
|
| - isEqualNodes(node.parameters, other.parameters) &&
|
| - isEqualTokens(node.semicolon, other.semicolon);
|
| - }
|
| -
|
| - @override
|
| - bool visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
|
| - FunctionTypedFormalParameter other = _other as FunctionTypedFormalParameter;
|
| - return isEqualNodes(
|
| - node.documentationComment, other.documentationComment) &&
|
| - _isEqualNodeLists(node.metadata, other.metadata) &&
|
| - isEqualNodes(node.returnType, other.returnType) &&
|
| - isEqualNodes(node.identifier, other.identifier) &&
|
| - isEqualNodes(node.parameters, other.parameters);
|
| - }
|
| -
|
| - @override
|
| - bool visitHideCombinator(HideCombinator node) {
|
| - HideCombinator other = _other as HideCombinator;
|
| - return isEqualTokens(node.keyword, other.keyword) &&
|
| - _isEqualNodeLists(node.hiddenNames, other.hiddenNames);
|
| - }
|
| -
|
| - @override
|
| - bool visitIfStatement(IfStatement node) {
|
| - IfStatement other = _other as IfStatement;
|
| - return isEqualTokens(node.ifKeyword, other.ifKeyword) &&
|
| - isEqualTokens(node.leftParenthesis, other.leftParenthesis) &&
|
| - isEqualNodes(node.condition, other.condition) &&
|
| - isEqualTokens(node.rightParenthesis, other.rightParenthesis) &&
|
| - isEqualNodes(node.thenStatement, other.thenStatement) &&
|
| - isEqualTokens(node.elseKeyword, other.elseKeyword) &&
|
| - isEqualNodes(node.elseStatement, other.elseStatement);
|
| - }
|
| -
|
| - @override
|
| - bool visitImplementsClause(ImplementsClause node) {
|
| - ImplementsClause other = _other as ImplementsClause;
|
| - return isEqualTokens(node.implementsKeyword, other.implementsKeyword) &&
|
| - _isEqualNodeLists(node.interfaces, other.interfaces);
|
| - }
|
| -
|
| - @override
|
| - bool visitImportDirective(ImportDirective node) {
|
| - ImportDirective other = _other as ImportDirective;
|
| - return isEqualNodes(
|
| - node.documentationComment, other.documentationComment) &&
|
| - _isEqualNodeLists(node.metadata, other.metadata) &&
|
| - isEqualTokens(node.keyword, other.keyword) &&
|
| - isEqualNodes(node.uri, other.uri) &&
|
| - isEqualTokens(node.deferredKeyword, other.deferredKeyword) &&
|
| - isEqualTokens(node.asKeyword, other.asKeyword) &&
|
| - isEqualNodes(node.prefix, other.prefix) &&
|
| - _isEqualNodeLists(node.combinators, other.combinators) &&
|
| - isEqualTokens(node.semicolon, other.semicolon);
|
| - }
|
| -
|
| - @override
|
| - bool visitIndexExpression(IndexExpression node) {
|
| - IndexExpression other = _other as IndexExpression;
|
| - return isEqualNodes(node.target, other.target) &&
|
| - isEqualTokens(node.leftBracket, other.leftBracket) &&
|
| - isEqualNodes(node.index, other.index) &&
|
| - isEqualTokens(node.rightBracket, other.rightBracket);
|
| - }
|
| -
|
| - @override
|
| - bool visitInstanceCreationExpression(InstanceCreationExpression node) {
|
| - InstanceCreationExpression other = _other as InstanceCreationExpression;
|
| - return isEqualTokens(node.keyword, other.keyword) &&
|
| - isEqualNodes(node.constructorName, other.constructorName) &&
|
| - isEqualNodes(node.argumentList, other.argumentList);
|
| - }
|
| -
|
| - @override
|
| - bool visitIntegerLiteral(IntegerLiteral node) {
|
| - IntegerLiteral other = _other as IntegerLiteral;
|
| - return isEqualTokens(node.literal, other.literal) &&
|
| - (node.value == other.value);
|
| - }
|
| -
|
| - @override
|
| - bool visitInterpolationExpression(InterpolationExpression node) {
|
| - InterpolationExpression other = _other as InterpolationExpression;
|
| - return isEqualTokens(node.leftBracket, other.leftBracket) &&
|
| - isEqualNodes(node.expression, other.expression) &&
|
| - isEqualTokens(node.rightBracket, other.rightBracket);
|
| - }
|
| -
|
| - @override
|
| - bool visitInterpolationString(InterpolationString node) {
|
| - InterpolationString other = _other as InterpolationString;
|
| - return isEqualTokens(node.contents, other.contents) &&
|
| - node.value == other.value;
|
| - }
|
| -
|
| - @override
|
| - bool visitIsExpression(IsExpression node) {
|
| - IsExpression other = _other as IsExpression;
|
| - return isEqualNodes(node.expression, other.expression) &&
|
| - isEqualTokens(node.isOperator, other.isOperator) &&
|
| - isEqualTokens(node.notOperator, other.notOperator) &&
|
| - isEqualNodes(node.type, other.type);
|
| - }
|
| -
|
| - @override
|
| - bool visitLabel(Label node) {
|
| - Label other = _other as Label;
|
| - return isEqualNodes(node.label, other.label) &&
|
| - isEqualTokens(node.colon, other.colon);
|
| - }
|
| -
|
| - @override
|
| - bool visitLabeledStatement(LabeledStatement node) {
|
| - LabeledStatement other = _other as LabeledStatement;
|
| - return _isEqualNodeLists(node.labels, other.labels) &&
|
| - isEqualNodes(node.statement, other.statement);
|
| - }
|
| -
|
| - @override
|
| - bool visitLibraryDirective(LibraryDirective node) {
|
| - LibraryDirective other = _other as LibraryDirective;
|
| - return isEqualNodes(
|
| - node.documentationComment, other.documentationComment) &&
|
| - _isEqualNodeLists(node.metadata, other.metadata) &&
|
| - isEqualTokens(node.libraryKeyword, other.libraryKeyword) &&
|
| - isEqualNodes(node.name, other.name) &&
|
| - isEqualTokens(node.semicolon, other.semicolon);
|
| - }
|
| -
|
| - @override
|
| - bool visitLibraryIdentifier(LibraryIdentifier node) {
|
| - LibraryIdentifier other = _other as LibraryIdentifier;
|
| - return _isEqualNodeLists(node.components, other.components);
|
| - }
|
| -
|
| - @override
|
| - bool visitListLiteral(ListLiteral node) {
|
| - ListLiteral other = _other as ListLiteral;
|
| - return isEqualTokens(node.constKeyword, other.constKeyword) &&
|
| - isEqualNodes(node.typeArguments, other.typeArguments) &&
|
| - isEqualTokens(node.leftBracket, other.leftBracket) &&
|
| - _isEqualNodeLists(node.elements, other.elements) &&
|
| - isEqualTokens(node.rightBracket, other.rightBracket);
|
| - }
|
| -
|
| - @override
|
| - bool visitMapLiteral(MapLiteral node) {
|
| - MapLiteral other = _other as MapLiteral;
|
| - return isEqualTokens(node.constKeyword, other.constKeyword) &&
|
| - isEqualNodes(node.typeArguments, other.typeArguments) &&
|
| - isEqualTokens(node.leftBracket, other.leftBracket) &&
|
| - _isEqualNodeLists(node.entries, other.entries) &&
|
| - isEqualTokens(node.rightBracket, other.rightBracket);
|
| - }
|
| -
|
| - @override
|
| - bool visitMapLiteralEntry(MapLiteralEntry node) {
|
| - MapLiteralEntry other = _other as MapLiteralEntry;
|
| - return isEqualNodes(node.key, other.key) &&
|
| - isEqualTokens(node.separator, other.separator) &&
|
| - isEqualNodes(node.value, other.value);
|
| - }
|
| -
|
| - @override
|
| - bool visitMethodDeclaration(MethodDeclaration node) {
|
| - MethodDeclaration other = _other as MethodDeclaration;
|
| - return isEqualNodes(
|
| - node.documentationComment, other.documentationComment) &&
|
| - _isEqualNodeLists(node.metadata, other.metadata) &&
|
| - isEqualTokens(node.externalKeyword, other.externalKeyword) &&
|
| - isEqualTokens(node.modifierKeyword, other.modifierKeyword) &&
|
| - isEqualNodes(node.returnType, other.returnType) &&
|
| - isEqualTokens(node.propertyKeyword, other.propertyKeyword) &&
|
| - isEqualTokens(node.propertyKeyword, other.propertyKeyword) &&
|
| - isEqualNodes(node.name, other.name) &&
|
| - isEqualNodes(node.parameters, other.parameters) &&
|
| - isEqualNodes(node.body, other.body);
|
| - }
|
| -
|
| - @override
|
| - bool visitMethodInvocation(MethodInvocation node) {
|
| - MethodInvocation other = _other as MethodInvocation;
|
| - return isEqualNodes(node.target, other.target) &&
|
| - isEqualTokens(node.operator, other.operator) &&
|
| - isEqualNodes(node.methodName, other.methodName) &&
|
| - isEqualNodes(node.argumentList, other.argumentList);
|
| - }
|
| -
|
| - @override
|
| - bool visitNamedExpression(NamedExpression node) {
|
| - NamedExpression other = _other as NamedExpression;
|
| - return isEqualNodes(node.name, other.name) &&
|
| - isEqualNodes(node.expression, other.expression);
|
| - }
|
| -
|
| - @override
|
| - bool visitNativeClause(NativeClause node) {
|
| - NativeClause other = _other as NativeClause;
|
| - return isEqualTokens(node.nativeKeyword, other.nativeKeyword) &&
|
| - isEqualNodes(node.name, other.name);
|
| - }
|
| -
|
| - @override
|
| - bool visitNativeFunctionBody(NativeFunctionBody node) {
|
| - NativeFunctionBody other = _other as NativeFunctionBody;
|
| - return isEqualTokens(node.nativeKeyword, other.nativeKeyword) &&
|
| - isEqualNodes(node.stringLiteral, other.stringLiteral) &&
|
| - isEqualTokens(node.semicolon, other.semicolon);
|
| - }
|
| -
|
| - @override
|
| - bool visitNullLiteral(NullLiteral node) {
|
| - NullLiteral other = _other as NullLiteral;
|
| - return isEqualTokens(node.literal, other.literal);
|
| - }
|
| -
|
| - @override
|
| - bool visitParenthesizedExpression(ParenthesizedExpression node) {
|
| - ParenthesizedExpression other = _other as ParenthesizedExpression;
|
| - return isEqualTokens(node.leftParenthesis, other.leftParenthesis) &&
|
| - isEqualNodes(node.expression, other.expression) &&
|
| - isEqualTokens(node.rightParenthesis, other.rightParenthesis);
|
| - }
|
| -
|
| - @override
|
| - bool visitPartDirective(PartDirective node) {
|
| - PartDirective other = _other as PartDirective;
|
| - return isEqualNodes(
|
| - node.documentationComment, other.documentationComment) &&
|
| - _isEqualNodeLists(node.metadata, other.metadata) &&
|
| - isEqualTokens(node.partKeyword, other.partKeyword) &&
|
| - isEqualNodes(node.uri, other.uri) &&
|
| - isEqualTokens(node.semicolon, other.semicolon);
|
| - }
|
| -
|
| - @override
|
| - bool visitPartOfDirective(PartOfDirective node) {
|
| - PartOfDirective other = _other as PartOfDirective;
|
| - return isEqualNodes(
|
| - node.documentationComment, other.documentationComment) &&
|
| - _isEqualNodeLists(node.metadata, other.metadata) &&
|
| - isEqualTokens(node.partKeyword, other.partKeyword) &&
|
| - isEqualTokens(node.ofKeyword, other.ofKeyword) &&
|
| - isEqualNodes(node.libraryName, other.libraryName) &&
|
| - isEqualTokens(node.semicolon, other.semicolon);
|
| - }
|
| -
|
| - @override
|
| - bool visitPostfixExpression(PostfixExpression node) {
|
| - PostfixExpression other = _other as PostfixExpression;
|
| - return isEqualNodes(node.operand, other.operand) &&
|
| - isEqualTokens(node.operator, other.operator);
|
| - }
|
| -
|
| - @override
|
| - bool visitPrefixedIdentifier(PrefixedIdentifier node) {
|
| - PrefixedIdentifier other = _other as PrefixedIdentifier;
|
| - return isEqualNodes(node.prefix, other.prefix) &&
|
| - isEqualTokens(node.period, other.period) &&
|
| - isEqualNodes(node.identifier, other.identifier);
|
| - }
|
| -
|
| - @override
|
| - bool visitPrefixExpression(PrefixExpression node) {
|
| - PrefixExpression other = _other as PrefixExpression;
|
| - return isEqualTokens(node.operator, other.operator) &&
|
| - isEqualNodes(node.operand, other.operand);
|
| - }
|
| -
|
| - @override
|
| - bool visitPropertyAccess(PropertyAccess node) {
|
| - PropertyAccess other = _other as PropertyAccess;
|
| - return isEqualNodes(node.target, other.target) &&
|
| - isEqualTokens(node.operator, other.operator) &&
|
| - isEqualNodes(node.propertyName, other.propertyName);
|
| - }
|
| -
|
| - @override
|
| - bool visitRedirectingConstructorInvocation(
|
| - RedirectingConstructorInvocation node) {
|
| - RedirectingConstructorInvocation other =
|
| - _other as RedirectingConstructorInvocation;
|
| - return isEqualTokens(node.thisKeyword, other.thisKeyword) &&
|
| - isEqualTokens(node.period, other.period) &&
|
| - isEqualNodes(node.constructorName, other.constructorName) &&
|
| - isEqualNodes(node.argumentList, other.argumentList);
|
| - }
|
| -
|
| - @override
|
| - bool visitRethrowExpression(RethrowExpression node) {
|
| - RethrowExpression other = _other as RethrowExpression;
|
| - return isEqualTokens(node.rethrowKeyword, other.rethrowKeyword);
|
| - }
|
| -
|
| - @override
|
| - bool visitReturnStatement(ReturnStatement node) {
|
| - ReturnStatement other = _other as ReturnStatement;
|
| - return isEqualTokens(node.returnKeyword, other.returnKeyword) &&
|
| - isEqualNodes(node.expression, other.expression) &&
|
| - isEqualTokens(node.semicolon, other.semicolon);
|
| - }
|
| -
|
| - @override
|
| - bool visitScriptTag(ScriptTag node) {
|
| - ScriptTag other = _other as ScriptTag;
|
| - return isEqualTokens(node.scriptTag, other.scriptTag);
|
| - }
|
| -
|
| - @override
|
| - bool visitShowCombinator(ShowCombinator node) {
|
| - ShowCombinator other = _other as ShowCombinator;
|
| - return isEqualTokens(node.keyword, other.keyword) &&
|
| - _isEqualNodeLists(node.shownNames, other.shownNames);
|
| - }
|
| -
|
| - @override
|
| - bool visitSimpleFormalParameter(SimpleFormalParameter node) {
|
| - SimpleFormalParameter other = _other as SimpleFormalParameter;
|
| - return isEqualNodes(
|
| - node.documentationComment, other.documentationComment) &&
|
| - _isEqualNodeLists(node.metadata, other.metadata) &&
|
| - isEqualTokens(node.keyword, other.keyword) &&
|
| - isEqualNodes(node.type, other.type) &&
|
| - isEqualNodes(node.identifier, other.identifier);
|
| - }
|
| -
|
| - @override
|
| - bool visitSimpleIdentifier(SimpleIdentifier node) {
|
| - SimpleIdentifier other = _other as SimpleIdentifier;
|
| - return isEqualTokens(node.token, other.token);
|
| - }
|
| -
|
| - @override
|
| - bool visitSimpleStringLiteral(SimpleStringLiteral node) {
|
| - SimpleStringLiteral other = _other as SimpleStringLiteral;
|
| - return isEqualTokens(node.literal, other.literal) &&
|
| - (node.value == other.value);
|
| - }
|
| -
|
| - @override
|
| - bool visitStringInterpolation(StringInterpolation node) {
|
| - StringInterpolation other = _other as StringInterpolation;
|
| - return _isEqualNodeLists(node.elements, other.elements);
|
| - }
|
| -
|
| - @override
|
| - bool visitSuperConstructorInvocation(SuperConstructorInvocation node) {
|
| - SuperConstructorInvocation other = _other as SuperConstructorInvocation;
|
| - return isEqualTokens(node.superKeyword, other.superKeyword) &&
|
| - isEqualTokens(node.period, other.period) &&
|
| - isEqualNodes(node.constructorName, other.constructorName) &&
|
| - isEqualNodes(node.argumentList, other.argumentList);
|
| - }
|
| -
|
| - @override
|
| - bool visitSuperExpression(SuperExpression node) {
|
| - SuperExpression other = _other as SuperExpression;
|
| - return isEqualTokens(node.superKeyword, other.superKeyword);
|
| - }
|
| -
|
| - @override
|
| - bool visitSwitchCase(SwitchCase node) {
|
| - SwitchCase other = _other as SwitchCase;
|
| - return _isEqualNodeLists(node.labels, other.labels) &&
|
| - isEqualTokens(node.keyword, other.keyword) &&
|
| - isEqualNodes(node.expression, other.expression) &&
|
| - isEqualTokens(node.colon, other.colon) &&
|
| - _isEqualNodeLists(node.statements, other.statements);
|
| - }
|
| -
|
| - @override
|
| - bool visitSwitchDefault(SwitchDefault node) {
|
| - SwitchDefault other = _other as SwitchDefault;
|
| - return _isEqualNodeLists(node.labels, other.labels) &&
|
| - isEqualTokens(node.keyword, other.keyword) &&
|
| - isEqualTokens(node.colon, other.colon) &&
|
| - _isEqualNodeLists(node.statements, other.statements);
|
| - }
|
| -
|
| - @override
|
| - bool visitSwitchStatement(SwitchStatement node) {
|
| - SwitchStatement other = _other as SwitchStatement;
|
| - return isEqualTokens(node.switchKeyword, other.switchKeyword) &&
|
| - isEqualTokens(node.leftParenthesis, other.leftParenthesis) &&
|
| - isEqualNodes(node.expression, other.expression) &&
|
| - isEqualTokens(node.rightParenthesis, other.rightParenthesis) &&
|
| - isEqualTokens(node.leftBracket, other.leftBracket) &&
|
| - _isEqualNodeLists(node.members, other.members) &&
|
| - isEqualTokens(node.rightBracket, other.rightBracket);
|
| - }
|
| -
|
| - @override
|
| - bool visitSymbolLiteral(SymbolLiteral node) {
|
| - SymbolLiteral other = _other as SymbolLiteral;
|
| - return isEqualTokens(node.poundSign, other.poundSign) &&
|
| - _isEqualTokenLists(node.components, other.components);
|
| - }
|
| -
|
| - @override
|
| - bool visitThisExpression(ThisExpression node) {
|
| - ThisExpression other = _other as ThisExpression;
|
| - return isEqualTokens(node.thisKeyword, other.thisKeyword);
|
| - }
|
| -
|
| - @override
|
| - bool visitThrowExpression(ThrowExpression node) {
|
| - ThrowExpression other = _other as ThrowExpression;
|
| - return isEqualTokens(node.throwKeyword, other.throwKeyword) &&
|
| - isEqualNodes(node.expression, other.expression);
|
| - }
|
| -
|
| - @override
|
| - bool visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
|
| - TopLevelVariableDeclaration other = _other as TopLevelVariableDeclaration;
|
| - return isEqualNodes(
|
| - node.documentationComment, other.documentationComment) &&
|
| - _isEqualNodeLists(node.metadata, other.metadata) &&
|
| - isEqualNodes(node.variables, other.variables) &&
|
| - isEqualTokens(node.semicolon, other.semicolon);
|
| - }
|
| -
|
| - @override
|
| - bool visitTryStatement(TryStatement node) {
|
| - TryStatement other = _other as TryStatement;
|
| - return isEqualTokens(node.tryKeyword, other.tryKeyword) &&
|
| - isEqualNodes(node.body, other.body) &&
|
| - _isEqualNodeLists(node.catchClauses, other.catchClauses) &&
|
| - isEqualTokens(node.finallyKeyword, other.finallyKeyword) &&
|
| - isEqualNodes(node.finallyBlock, other.finallyBlock);
|
| - }
|
| -
|
| - @override
|
| - bool visitTypeArgumentList(TypeArgumentList node) {
|
| - TypeArgumentList other = _other as TypeArgumentList;
|
| - return isEqualTokens(node.leftBracket, other.leftBracket) &&
|
| - _isEqualNodeLists(node.arguments, other.arguments) &&
|
| - isEqualTokens(node.rightBracket, other.rightBracket);
|
| - }
|
| -
|
| - @override
|
| - bool visitTypeName(TypeName node) {
|
| - TypeName other = _other as TypeName;
|
| - return isEqualNodes(node.name, other.name) &&
|
| - isEqualNodes(node.typeArguments, other.typeArguments);
|
| - }
|
| -
|
| - @override
|
| - bool visitTypeParameter(TypeParameter node) {
|
| - TypeParameter other = _other as TypeParameter;
|
| - return isEqualNodes(
|
| - node.documentationComment, other.documentationComment) &&
|
| - _isEqualNodeLists(node.metadata, other.metadata) &&
|
| - isEqualNodes(node.name, other.name) &&
|
| - isEqualTokens(node.extendsKeyword, other.extendsKeyword) &&
|
| - isEqualNodes(node.bound, other.bound);
|
| - }
|
| -
|
| - @override
|
| - bool visitTypeParameterList(TypeParameterList node) {
|
| - TypeParameterList other = _other as TypeParameterList;
|
| - return isEqualTokens(node.leftBracket, other.leftBracket) &&
|
| - _isEqualNodeLists(node.typeParameters, other.typeParameters) &&
|
| - isEqualTokens(node.rightBracket, other.rightBracket);
|
| - }
|
| -
|
| - @override
|
| - bool visitVariableDeclaration(VariableDeclaration node) {
|
| - VariableDeclaration other = _other as VariableDeclaration;
|
| - return isEqualNodes(
|
| - node.documentationComment, other.documentationComment) &&
|
| - _isEqualNodeLists(node.metadata, other.metadata) &&
|
| - isEqualNodes(node.name, other.name) &&
|
| - isEqualTokens(node.equals, other.equals) &&
|
| - isEqualNodes(node.initializer, other.initializer);
|
| - }
|
| -
|
| - @override
|
| - bool visitVariableDeclarationList(VariableDeclarationList node) {
|
| - VariableDeclarationList other = _other as VariableDeclarationList;
|
| - return isEqualNodes(
|
| - node.documentationComment, other.documentationComment) &&
|
| - _isEqualNodeLists(node.metadata, other.metadata) &&
|
| - isEqualTokens(node.keyword, other.keyword) &&
|
| - isEqualNodes(node.type, other.type) &&
|
| - _isEqualNodeLists(node.variables, other.variables);
|
| - }
|
| -
|
| - @override
|
| - bool visitVariableDeclarationStatement(VariableDeclarationStatement node) {
|
| - VariableDeclarationStatement other = _other as VariableDeclarationStatement;
|
| - return isEqualNodes(node.variables, other.variables) &&
|
| - isEqualTokens(node.semicolon, other.semicolon);
|
| - }
|
| -
|
| - @override
|
| - bool visitWhileStatement(WhileStatement node) {
|
| - WhileStatement other = _other as WhileStatement;
|
| - return isEqualTokens(node.whileKeyword, other.whileKeyword) &&
|
| - isEqualTokens(node.leftParenthesis, other.leftParenthesis) &&
|
| - isEqualNodes(node.condition, other.condition) &&
|
| - isEqualTokens(node.rightParenthesis, other.rightParenthesis) &&
|
| - isEqualNodes(node.body, other.body);
|
| - }
|
| -
|
| - @override
|
| - bool visitWithClause(WithClause node) {
|
| - WithClause other = _other as WithClause;
|
| - return isEqualTokens(node.withKeyword, other.withKeyword) &&
|
| - _isEqualNodeLists(node.mixinTypes, other.mixinTypes);
|
| - }
|
| -
|
| - @override
|
| - bool visitYieldStatement(YieldStatement node) {
|
| - YieldStatement other = _other as YieldStatement;
|
| - return isEqualTokens(node.yieldKeyword, other.yieldKeyword) &&
|
| - isEqualNodes(node.expression, other.expression) &&
|
| - isEqualTokens(node.semicolon, other.semicolon);
|
| - }
|
| -
|
| - /**
|
| - * Return `true` if the [first] and [second] lists of AST nodes have the same
|
| - * size and corresponding elements are equal.
|
| - */
|
| - bool _isEqualNodeLists(NodeList first, NodeList second) {
|
| - if (first == null) {
|
| - return second == null;
|
| - } else if (second == null) {
|
| - return false;
|
| - }
|
| - int size = first.length;
|
| - if (second.length != size) {
|
| - return false;
|
| - }
|
| - for (int i = 0; i < size; i++) {
|
| - if (!isEqualNodes(first[i], second[i])) {
|
| - return false;
|
| - }
|
| - }
|
| - return true;
|
| - }
|
| -
|
| - /**
|
| - * Return `true` if the [first] and [second] lists of tokens have the same
|
| - * length and corresponding elements are equal.
|
| - */
|
| - bool _isEqualTokenLists(List<Token> first, List<Token> second) {
|
| - int length = first.length;
|
| - if (second.length != length) {
|
| - return false;
|
| - }
|
| - for (int i = 0; i < length; i++) {
|
| - if (!isEqualTokens(first[i], second[i])) {
|
| - return false;
|
| - }
|
| - }
|
| - return true;
|
| - }
|
| -
|
| - /**
|
| - * Return `true` if the [first] and [second] nodes are equal.
|
| - */
|
| - static bool equalNodes(AstNode first, AstNode second) {
|
| - AstComparator comparator = new AstComparator();
|
| - return comparator.isEqualNodes(first, second);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A node in the AST structure for a Dart program.
|
| - */
|
| -abstract class AstNode {
|
| - /**
|
| - * An empty list of AST nodes.
|
| - */
|
| - @deprecated // Use "AstNode.EMPTY_LIST"
|
| - static const List<AstNode> EMPTY_ARRAY = EMPTY_LIST;
|
| -
|
| - /**
|
| - * An empty list of AST nodes.
|
| - */
|
| - static const List<AstNode> EMPTY_LIST = const <AstNode>[];
|
| -
|
| - /**
|
| - * A comparator that can be used to sort AST nodes in lexical order. In other
|
| - * words, `compare` will return a negative value if the offset of the first
|
| - * node is less than the offset of the second node, zero (0) if the nodes have
|
| - * the same offset, and a positive value if the offset of the first node is
|
| - * greater than the offset of the second node.
|
| - */
|
| - static Comparator<AstNode> LEXICAL_ORDER =
|
| - (AstNode first, AstNode second) => second.offset - first.offset;
|
| -
|
| - /**
|
| - * The parent of the node, or `null` if the node is the root of an AST
|
| - * structure.
|
| - */
|
| - AstNode _parent;
|
| -
|
| - /**
|
| - * A table mapping the names of properties to their values, or `null` if this
|
| - * node does not have any properties associated with it.
|
| - */
|
| - Map<String, Object> _propertyMap;
|
| -
|
| - /**
|
| - * Return the first token included in this node's source range.
|
| - */
|
| - Token get beginToken;
|
| -
|
| - /**
|
| - * Iterate through all the entities (either AST nodes or tokens) which make
|
| - * up the contents of this node, including doc comments but excluding other
|
| - * comments.
|
| - */
|
| - Iterable /*<AstNode | Token>*/ get childEntities;
|
| -
|
| - /**
|
| - * Return the offset of the character immediately following the last character
|
| - * of this node's source range. This is equivalent to
|
| - * `node.getOffset() + node.getLength()`. For a compilation unit this will be
|
| - * equal to the length of the unit's source. For synthetic nodes this will be
|
| - * equivalent to the node's offset (because the length is zero (0) by
|
| - * definition).
|
| - */
|
| - int get end => offset + length;
|
| -
|
| - /**
|
| - * Return the last token included in this node's source range.
|
| - */
|
| - Token get endToken;
|
| -
|
| - /**
|
| - * Return `true` if this node is a synthetic node. A synthetic node is a node
|
| - * that was introduced by the parser in order to recover from an error in the
|
| - * code. Synthetic nodes always have a length of zero (`0`).
|
| - */
|
| - bool get isSynthetic => false;
|
| -
|
| - /**
|
| - * Return the number of characters in the node's source range.
|
| - */
|
| - int get length {
|
| - Token beginToken = this.beginToken;
|
| - Token endToken = this.endToken;
|
| - if (beginToken == null || endToken == null) {
|
| - return -1;
|
| - }
|
| - return endToken.offset + endToken.length - beginToken.offset;
|
| - }
|
| -
|
| - /**
|
| - * Return the offset from the beginning of the file to the first character in
|
| - * the node's source range.
|
| - */
|
| - int get offset {
|
| - Token beginToken = this.beginToken;
|
| - if (beginToken == null) {
|
| - return -1;
|
| - }
|
| - return beginToken.offset;
|
| - }
|
| -
|
| - /**
|
| - * Return this node's parent node, or `null` if this node is the root of an
|
| - * AST structure.
|
| - *
|
| - * Note that the relationship between an AST node and its parent node may
|
| - * change over the lifetime of a node.
|
| - */
|
| - AstNode get parent => _parent;
|
| -
|
| - /**
|
| - * Set the parent of this node to the [newParent].
|
| - */
|
| - @deprecated // Never intended for public use.
|
| - void set parent(AstNode newParent) {
|
| - _parent = newParent;
|
| - }
|
| -
|
| - /**
|
| - * Return the node at the root of this node's AST structure. Note that this
|
| - * method's performance is linear with respect to the depth of the node in the
|
| - * AST structure (O(depth)).
|
| - */
|
| - AstNode get root {
|
| - AstNode root = this;
|
| - AstNode parent = this.parent;
|
| - while (parent != null) {
|
| - root = parent;
|
| - parent = root.parent;
|
| - }
|
| - return root;
|
| - }
|
| -
|
| - /**
|
| - * Use the given [visitor] to visit this node. Return the value returned by
|
| - * the visitor as a result of visiting this node.
|
| - */
|
| - /* <E> E */ accept(AstVisitor /*<E>*/ visitor);
|
| -
|
| - /**
|
| - * Make this node the parent of the given [child] node. Return the child node.
|
| - */
|
| - @deprecated // Never intended for public use.
|
| - AstNode becomeParentOf(AstNode child) {
|
| - return _becomeParentOf(child);
|
| - }
|
| -
|
| - /**
|
| - * Return the most immediate ancestor of this node for which the [predicate]
|
| - * returns `true`, or `null` if there is no such ancestor. Note that this node
|
| - * will never be returned.
|
| - */
|
| - AstNode getAncestor(Predicate<AstNode> predicate) {
|
| - // TODO(brianwilkerson) It is a bug that this method can return `this`.
|
| - AstNode node = this;
|
| - while (node != null && !predicate(node)) {
|
| - node = node.parent;
|
| - }
|
| - return node;
|
| - }
|
| -
|
| - /**
|
| - * Return the value of the property with the given [name], or `null` if this
|
| - * node does not have a property with the given name.
|
| - */
|
| - Object getProperty(String name) {
|
| - if (_propertyMap == null) {
|
| - return null;
|
| - }
|
| - return _propertyMap[name];
|
| - }
|
| -
|
| - /**
|
| - * If the given [child] is not `null`, use the given [visitor] to visit it.
|
| - */
|
| - @deprecated // Never intended for public use.
|
| - void safelyVisitChild(AstNode child, AstVisitor visitor) {
|
| - if (child != null) {
|
| - child.accept(visitor);
|
| - }
|
| - }
|
| -
|
| - /**
|
| - * Set the value of the property with the given [name] to the given [value].
|
| - * If the value is `null`, the property will effectively be removed.
|
| - */
|
| - void setProperty(String name, Object value) {
|
| - if (value == null) {
|
| - if (_propertyMap != null) {
|
| - _propertyMap.remove(name);
|
| - if (_propertyMap.isEmpty) {
|
| - _propertyMap = null;
|
| - }
|
| - }
|
| - } else {
|
| - if (_propertyMap == null) {
|
| - _propertyMap = new HashMap<String, Object>();
|
| - }
|
| - _propertyMap[name] = value;
|
| - }
|
| - }
|
| -
|
| - /**
|
| - * Return a textual description of this node in a form approximating valid
|
| - * source. The returned string will not be valid source primarily in the case
|
| - * where the node itself is not well-formed.
|
| - */
|
| - String toSource() {
|
| - PrintStringWriter writer = new PrintStringWriter();
|
| - accept(new ToSourceVisitor(writer));
|
| - return writer.toString();
|
| - }
|
| -
|
| - @override
|
| - String toString() => toSource();
|
| -
|
| - /**
|
| - * Use the given [visitor] to visit all of the children of this node. The
|
| - * children will be visited in lexical order.
|
| - */
|
| - void visitChildren(AstVisitor visitor);
|
| -
|
| - /**
|
| - * Make this node the parent of the given [child] node. Return the child node.
|
| - */
|
| - AstNode _becomeParentOf(AstNode child) {
|
| - if (child != null) {
|
| - child._parent = this;
|
| - }
|
| - return child;
|
| - }
|
| -
|
| - /**
|
| - * If the given [child] is not `null`, use the given [visitor] to visit it.
|
| - */
|
| - void _safelyVisitChild(AstNode child, AstVisitor visitor) {
|
| - if (child != null) {
|
| - child.accept(visitor);
|
| - }
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * An object that can be used to visit an AST structure.
|
| - */
|
| -abstract class AstVisitor<R> {
|
| - R visitAdjacentStrings(AdjacentStrings node);
|
| -
|
| - R visitAnnotation(Annotation node);
|
| -
|
| - R visitArgumentList(ArgumentList node);
|
| -
|
| - R visitAsExpression(AsExpression node);
|
| -
|
| - R visitAssertStatement(AssertStatement assertStatement);
|
| -
|
| - R visitAssignmentExpression(AssignmentExpression node);
|
| -
|
| - R visitAwaitExpression(AwaitExpression node);
|
| -
|
| - R visitBinaryExpression(BinaryExpression node);
|
| -
|
| - R visitBlock(Block node);
|
| -
|
| - R visitBlockFunctionBody(BlockFunctionBody node);
|
| -
|
| - R visitBooleanLiteral(BooleanLiteral node);
|
| -
|
| - R visitBreakStatement(BreakStatement node);
|
| -
|
| - R visitCascadeExpression(CascadeExpression node);
|
| -
|
| - R visitCatchClause(CatchClause node);
|
| -
|
| - R visitClassDeclaration(ClassDeclaration node);
|
| -
|
| - R visitClassTypeAlias(ClassTypeAlias node);
|
| -
|
| - R visitComment(Comment node);
|
| -
|
| - R visitCommentReference(CommentReference node);
|
| -
|
| - R visitCompilationUnit(CompilationUnit node);
|
| -
|
| - R visitConditionalExpression(ConditionalExpression node);
|
| -
|
| - R visitConstructorDeclaration(ConstructorDeclaration node);
|
| -
|
| - R visitConstructorFieldInitializer(ConstructorFieldInitializer node);
|
| -
|
| - R visitConstructorName(ConstructorName node);
|
| -
|
| - R visitContinueStatement(ContinueStatement node);
|
| -
|
| - R visitDeclaredIdentifier(DeclaredIdentifier node);
|
| -
|
| - R visitDefaultFormalParameter(DefaultFormalParameter node);
|
| -
|
| - R visitDoStatement(DoStatement node);
|
| -
|
| - R visitDoubleLiteral(DoubleLiteral node);
|
| -
|
| - R visitEmptyFunctionBody(EmptyFunctionBody node);
|
| -
|
| - R visitEmptyStatement(EmptyStatement node);
|
| -
|
| - R visitEnumConstantDeclaration(EnumConstantDeclaration node);
|
| -
|
| - R visitEnumDeclaration(EnumDeclaration node);
|
| -
|
| - R visitExportDirective(ExportDirective node);
|
| -
|
| - R visitExpressionFunctionBody(ExpressionFunctionBody node);
|
| -
|
| - R visitExpressionStatement(ExpressionStatement node);
|
| -
|
| - R visitExtendsClause(ExtendsClause node);
|
| -
|
| - R visitFieldDeclaration(FieldDeclaration node);
|
| -
|
| - R visitFieldFormalParameter(FieldFormalParameter node);
|
| -
|
| - R visitForEachStatement(ForEachStatement node);
|
| -
|
| - R visitFormalParameterList(FormalParameterList node);
|
| -
|
| - R visitForStatement(ForStatement node);
|
| -
|
| - R visitFunctionDeclaration(FunctionDeclaration node);
|
| -
|
| - R visitFunctionDeclarationStatement(FunctionDeclarationStatement node);
|
| -
|
| - R visitFunctionExpression(FunctionExpression node);
|
| -
|
| - R visitFunctionExpressionInvocation(FunctionExpressionInvocation node);
|
| -
|
| - R visitFunctionTypeAlias(FunctionTypeAlias functionTypeAlias);
|
| -
|
| - R visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node);
|
| -
|
| - R visitHideCombinator(HideCombinator node);
|
| -
|
| - R visitIfStatement(IfStatement node);
|
| -
|
| - R visitImplementsClause(ImplementsClause node);
|
| -
|
| - R visitImportDirective(ImportDirective node);
|
| -
|
| - R visitIndexExpression(IndexExpression node);
|
| -
|
| - R visitInstanceCreationExpression(InstanceCreationExpression node);
|
| -
|
| - R visitIntegerLiteral(IntegerLiteral node);
|
| -
|
| - R visitInterpolationExpression(InterpolationExpression node);
|
| -
|
| - R visitInterpolationString(InterpolationString node);
|
| -
|
| - R visitIsExpression(IsExpression node);
|
| -
|
| - R visitLabel(Label node);
|
| -
|
| - R visitLabeledStatement(LabeledStatement node);
|
| -
|
| - R visitLibraryDirective(LibraryDirective node);
|
| -
|
| - R visitLibraryIdentifier(LibraryIdentifier node);
|
| -
|
| - R visitListLiteral(ListLiteral node);
|
| -
|
| - R visitMapLiteral(MapLiteral node);
|
| -
|
| - R visitMapLiteralEntry(MapLiteralEntry node);
|
| -
|
| - R visitMethodDeclaration(MethodDeclaration node);
|
| -
|
| - R visitMethodInvocation(MethodInvocation node);
|
| -
|
| - R visitNamedExpression(NamedExpression node);
|
| -
|
| - R visitNativeClause(NativeClause node);
|
| -
|
| - R visitNativeFunctionBody(NativeFunctionBody node);
|
| -
|
| - R visitNullLiteral(NullLiteral node);
|
| -
|
| - R visitParenthesizedExpression(ParenthesizedExpression node);
|
| -
|
| - R visitPartDirective(PartDirective node);
|
| -
|
| - R visitPartOfDirective(PartOfDirective node);
|
| -
|
| - R visitPostfixExpression(PostfixExpression node);
|
| -
|
| - R visitPrefixedIdentifier(PrefixedIdentifier node);
|
| -
|
| - R visitPrefixExpression(PrefixExpression node);
|
| -
|
| - R visitPropertyAccess(PropertyAccess node);
|
| -
|
| - R visitRedirectingConstructorInvocation(
|
| - RedirectingConstructorInvocation node);
|
| -
|
| - R visitRethrowExpression(RethrowExpression node);
|
| -
|
| - R visitReturnStatement(ReturnStatement node);
|
| -
|
| - R visitScriptTag(ScriptTag node);
|
| -
|
| - R visitShowCombinator(ShowCombinator node);
|
| -
|
| - R visitSimpleFormalParameter(SimpleFormalParameter node);
|
| -
|
| - R visitSimpleIdentifier(SimpleIdentifier node);
|
| -
|
| - R visitSimpleStringLiteral(SimpleStringLiteral node);
|
| -
|
| - R visitStringInterpolation(StringInterpolation node);
|
| -
|
| - R visitSuperConstructorInvocation(SuperConstructorInvocation node);
|
| -
|
| - R visitSuperExpression(SuperExpression node);
|
| -
|
| - R visitSwitchCase(SwitchCase node);
|
| -
|
| - R visitSwitchDefault(SwitchDefault node);
|
| -
|
| - R visitSwitchStatement(SwitchStatement node);
|
| -
|
| - R visitSymbolLiteral(SymbolLiteral node);
|
| -
|
| - R visitThisExpression(ThisExpression node);
|
| -
|
| - R visitThrowExpression(ThrowExpression node);
|
| -
|
| - R visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node);
|
| -
|
| - R visitTryStatement(TryStatement node);
|
| -
|
| - R visitTypeArgumentList(TypeArgumentList node);
|
| -
|
| - R visitTypeName(TypeName node);
|
| -
|
| - R visitTypeParameter(TypeParameter node);
|
| -
|
| - R visitTypeParameterList(TypeParameterList node);
|
| -
|
| - R visitVariableDeclaration(VariableDeclaration node);
|
| -
|
| - R visitVariableDeclarationList(VariableDeclarationList node);
|
| -
|
| - R visitVariableDeclarationStatement(VariableDeclarationStatement node);
|
| -
|
| - R visitWhileStatement(WhileStatement node);
|
| -
|
| - R visitWithClause(WithClause node);
|
| -
|
| - R visitYieldStatement(YieldStatement node);
|
| -}
|
| -
|
| -/**
|
| - * An await expression.
|
| - *
|
| - * > awaitExpression ::=
|
| - * > 'await' [Expression]
|
| - */
|
| -class AwaitExpression extends Expression {
|
| - /**
|
| - * The 'await' keyword.
|
| - */
|
| - Token awaitKeyword;
|
| -
|
| - /**
|
| - * The expression whose value is being waited on.
|
| - */
|
| - Expression _expression;
|
| -
|
| - /**
|
| - * Initialize a newly created await expression.
|
| - */
|
| - AwaitExpression(this.awaitKeyword, Expression expression) {
|
| - _expression = _becomeParentOf(expression);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken {
|
| - if (awaitKeyword != null) {
|
| - return awaitKeyword;
|
| - }
|
| - return _expression.beginToken;
|
| - }
|
| -
|
| - @override
|
| - Iterable get childEntities =>
|
| - new ChildEntities()..add(awaitKeyword)..add(_expression);
|
| -
|
| - @override
|
| - Token get endToken => _expression.endToken;
|
| -
|
| - /**
|
| - * Return the expression whose value is being waited on.
|
| - */
|
| - Expression get expression => _expression;
|
| -
|
| - /**
|
| - * Set the expression whose value is being waited on to the given [expression].
|
| - */
|
| - void set expression(Expression expression) {
|
| - _expression = _becomeParentOf(expression);
|
| - }
|
| -
|
| - @override
|
| - int get precedence => 0;
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitAwaitExpression(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_expression, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A binary (infix) expression.
|
| - *
|
| - * > binaryExpression ::=
|
| - * > [Expression] [Token] [Expression]
|
| - */
|
| -class BinaryExpression extends Expression {
|
| - /**
|
| - * The expression used to compute the left operand.
|
| - */
|
| - Expression _leftOperand;
|
| -
|
| - /**
|
| - * The binary operator being applied.
|
| - */
|
| - Token operator;
|
| -
|
| - /**
|
| - * The expression used to compute the right operand.
|
| - */
|
| - Expression _rightOperand;
|
| -
|
| - /**
|
| - * The element associated with the operator based on the static type of the
|
| - * left operand, or `null` if the AST structure has not been resolved, if the
|
| - * operator is not user definable, or if the operator could not be resolved.
|
| - */
|
| - MethodElement staticElement;
|
| -
|
| - /**
|
| - * The element associated with the operator based on the propagated type of
|
| - * the left operand, or `null` if the AST structure has not been resolved, if
|
| - * the operator is not user definable, or if the operator could not be
|
| - * resolved.
|
| - */
|
| - MethodElement propagatedElement;
|
| -
|
| - /**
|
| - * Initialize a newly created binary expression.
|
| - */
|
| - BinaryExpression(
|
| - Expression leftOperand, this.operator, Expression rightOperand) {
|
| - _leftOperand = _becomeParentOf(leftOperand);
|
| - _rightOperand = _becomeParentOf(rightOperand);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => _leftOperand.beginToken;
|
| -
|
| - /**
|
| - * Return the best element available for this operator. If resolution was able
|
| - * to find a better element based on type propagation, that element will be
|
| - * returned. Otherwise, the element found using the result of static analysis
|
| - * will be returned. If resolution has not been performed, then `null` will be
|
| - * returned.
|
| - */
|
| - MethodElement get bestElement {
|
| - MethodElement element = propagatedElement;
|
| - if (element == null) {
|
| - element = staticElement;
|
| - }
|
| - return element;
|
| - }
|
| -
|
| - @override
|
| - Iterable get childEntities =>
|
| - new ChildEntities()..add(_leftOperand)..add(operator)..add(_rightOperand);
|
| -
|
| - @override
|
| - Token get endToken => _rightOperand.endToken;
|
| -
|
| - /**
|
| - * Return the expression used to compute the left operand.
|
| - */
|
| - Expression get leftOperand => _leftOperand;
|
| -
|
| - /**
|
| - * Set the expression used to compute the left operand to the given
|
| - * [expression].
|
| - */
|
| - void set leftOperand(Expression expression) {
|
| - _leftOperand = _becomeParentOf(expression);
|
| - }
|
| -
|
| - @override
|
| - int get precedence => operator.type.precedence;
|
| -
|
| - /**
|
| - * If the AST structure has been resolved, and the function being invoked is
|
| - * known based on propagated type information, then return the parameter
|
| - * element representing the parameter to which the value of the right operand
|
| - * will be bound. Otherwise, return `null`.
|
| - */
|
| - @deprecated // Use "expression.propagatedParameterElement"
|
| - ParameterElement get propagatedParameterElementForRightOperand {
|
| - return _propagatedParameterElementForRightOperand;
|
| - }
|
| -
|
| - /**
|
| - * Return the expression used to compute the right operand.
|
| - */
|
| - Expression get rightOperand => _rightOperand;
|
| -
|
| - /**
|
| - * Set the expression used to compute the right operand to the given
|
| - * [expression].
|
| - */
|
| - void set rightOperand(Expression expression) {
|
| - _rightOperand = _becomeParentOf(expression);
|
| - }
|
| -
|
| - /**
|
| - * If the AST structure has been resolved, and the function being invoked is
|
| - * known based on static type information, then return the parameter element
|
| - * representing the parameter to which the value of the right operand will be
|
| - * bound. Otherwise, return `null`.
|
| - */
|
| - @deprecated // Use "expression.staticParameterElement"
|
| - ParameterElement get staticParameterElementForRightOperand {
|
| - return _staticParameterElementForRightOperand;
|
| - }
|
| -
|
| - /**
|
| - * If the AST structure has been resolved, and the function being invoked is
|
| - * known based on propagated type information, then return the parameter
|
| - * element representing the parameter to which the value of the right operand
|
| - * will be bound. Otherwise, return `null`.
|
| - */
|
| - ParameterElement get _propagatedParameterElementForRightOperand {
|
| - if (propagatedElement == null) {
|
| - return null;
|
| - }
|
| - List<ParameterElement> parameters = propagatedElement.parameters;
|
| - if (parameters.length < 1) {
|
| - return null;
|
| - }
|
| - return parameters[0];
|
| - }
|
| -
|
| - /**
|
| - * If the AST structure has been resolved, and the function being invoked is
|
| - * known based on static type information, then return the parameter element
|
| - * representing the parameter to which the value of the right operand will be
|
| - * bound. Otherwise, return `null`.
|
| - */
|
| - ParameterElement get _staticParameterElementForRightOperand {
|
| - if (staticElement == null) {
|
| - return null;
|
| - }
|
| - List<ParameterElement> parameters = staticElement.parameters;
|
| - if (parameters.length < 1) {
|
| - return null;
|
| - }
|
| - return parameters[0];
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitBinaryExpression(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_leftOperand, visitor);
|
| - _safelyVisitChild(_rightOperand, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A sequence of statements.
|
| - *
|
| - * > block ::=
|
| - * > '{' statement* '}'
|
| - */
|
| -class Block extends Statement {
|
| - /**
|
| - * The left curly bracket.
|
| - */
|
| - Token leftBracket;
|
| -
|
| - /**
|
| - * The statements contained in the block.
|
| - */
|
| - NodeList<Statement> _statements;
|
| -
|
| - /**
|
| - * The right curly bracket.
|
| - */
|
| - Token rightBracket;
|
| -
|
| - /**
|
| - * Initialize a newly created block of code.
|
| - */
|
| - Block(this.leftBracket, List<Statement> statements, this.rightBracket) {
|
| - _statements = new NodeList<Statement>(this, statements);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => leftBracket;
|
| -
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()
|
| - ..add(leftBracket)
|
| - ..addAll(_statements)
|
| - ..add(rightBracket);
|
| -
|
| - @override
|
| - Token get endToken => rightBracket;
|
| -
|
| - /**
|
| - * Return the statements contained in the block.
|
| - */
|
| - NodeList<Statement> get statements => _statements;
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitBlock(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _statements.accept(visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A function body that consists of a block of statements.
|
| - *
|
| - * > blockFunctionBody ::=
|
| - * > ('async' | 'async' '*' | 'sync' '*')? [Block]
|
| - */
|
| -class BlockFunctionBody extends FunctionBody {
|
| - /**
|
| - * The token representing the 'async' or 'sync' keyword, or `null` if there is
|
| - * no such keyword.
|
| - */
|
| - Token keyword;
|
| -
|
| - /**
|
| - * The star optionally following the 'async' or 'sync' keyword, or `null` if
|
| - * there is wither no such keyword or no star.
|
| - */
|
| - Token star;
|
| -
|
| - /**
|
| - * The block representing the body of the function.
|
| - */
|
| - Block _block;
|
| -
|
| - /**
|
| - * Initialize a newly created function body consisting of a block of
|
| - * statements. The [keyword] can be `null` if there is no keyword specified
|
| - * for the block. The [star] can be `null` if there is no star following the
|
| - * keyword (and must be `null` if there is no keyword).
|
| - */
|
| - BlockFunctionBody(this.keyword, this.star, Block block) {
|
| - _block = _becomeParentOf(block);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => _block.beginToken;
|
| -
|
| - /**
|
| - * Return the block representing the body of the function.
|
| - */
|
| - Block get block => _block;
|
| -
|
| - /**
|
| - * Set the block representing the body of the function to the given [block].
|
| - */
|
| - void set block(Block block) {
|
| - _block = _becomeParentOf(block);
|
| - }
|
| -
|
| - @override
|
| - Iterable get childEntities =>
|
| - new ChildEntities()..add(keyword)..add(star)..add(_block);
|
| -
|
| - @override
|
| - Token get endToken => _block.endToken;
|
| -
|
| - @override
|
| - bool get isAsynchronous => keyword != null && keyword.lexeme == Parser.ASYNC;
|
| -
|
| - @override
|
| - bool get isGenerator => star != null;
|
| -
|
| - @override
|
| - bool get isSynchronous => keyword == null || keyword.lexeme != Parser.ASYNC;
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitBlockFunctionBody(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_block, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A boolean literal expression.
|
| - *
|
| - * > booleanLiteral ::=
|
| - * > 'false' | 'true'
|
| - */
|
| -class BooleanLiteral extends Literal {
|
| - /**
|
| - * The token representing the literal.
|
| - */
|
| - Token literal;
|
| -
|
| - /**
|
| - * The value of the literal.
|
| - */
|
| - bool value = false;
|
| -
|
| - /**
|
| - * Initialize a newly created boolean literal.
|
| - */
|
| - BooleanLiteral(this.literal, this.value);
|
| -
|
| - @override
|
| - Token get beginToken => literal;
|
| -
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()..add(literal);
|
| -
|
| - @override
|
| - Token get endToken => literal;
|
| -
|
| - @override
|
| - bool get isSynthetic => literal.isSynthetic;
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitBooleanLiteral(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - // There are no children to visit.
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * An AST visitor that will recursively visit all of the nodes in an AST
|
| - * structure, similar to [GeneralizingAstVisitor]. This visitor uses a
|
| - * breadth-first ordering rather than the depth-first ordering of
|
| - * [GeneralizingAstVisitor].
|
| - *
|
| - * Subclasses that override a visit method must either invoke the overridden
|
| - * visit method or explicitly invoke the more general visit method. Failure to
|
| - * do so will cause the visit methods for superclasses of the node to not be
|
| - * invoked and will cause the children of the visited node to not be visited.
|
| - *
|
| - * In addition, subclasses should <b>not</b> explicitly visit the children of a
|
| - * node, but should ensure that the method [visitNode] is used to visit the
|
| - * children (either directly or indirectly). Failure to do will break the order
|
| - * in which nodes are visited.
|
| - */
|
| -class BreadthFirstVisitor<R> extends GeneralizingAstVisitor<R> {
|
| - /**
|
| - * A queue holding the nodes that have not yet been visited in the order in
|
| - * which they ought to be visited.
|
| - */
|
| - Queue<AstNode> _queue = new Queue<AstNode>();
|
| -
|
| - /**
|
| - * A visitor, used to visit the children of the current node, that will add
|
| - * the nodes it visits to the [_queue].
|
| - */
|
| - GeneralizingAstVisitor<Object> _childVisitor;
|
| -
|
| - /**
|
| - * Initialize a newly created visitor.
|
| - */
|
| - BreadthFirstVisitor() {
|
| - _childVisitor = new GeneralizingAstVisitor_BreadthFirstVisitor(this);
|
| - }
|
| -
|
| - /**
|
| - * Visit all nodes in the tree starting at the given [root] node, in
|
| - * breadth-first order.
|
| - */
|
| - void visitAllNodes(AstNode root) {
|
| - _queue.add(root);
|
| - while (!_queue.isEmpty) {
|
| - AstNode next = _queue.removeFirst();
|
| - next.accept(this);
|
| - }
|
| - }
|
| -
|
| - @override
|
| - R visitNode(AstNode node) {
|
| - node.visitChildren(_childVisitor);
|
| - return null;
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A break statement.
|
| - *
|
| - * > breakStatement ::=
|
| - * > 'break' [SimpleIdentifier]? ';'
|
| - */
|
| -class BreakStatement extends Statement {
|
| - /**
|
| - * The token representing the 'break' keyword.
|
| - */
|
| - Token breakKeyword;
|
| -
|
| - /**
|
| - * The label associated with the statement, or `null` if there is no label.
|
| - */
|
| - SimpleIdentifier _label;
|
| -
|
| - /**
|
| - * The semicolon terminating the statement.
|
| - */
|
| - Token semicolon;
|
| -
|
| - /**
|
| - * The AstNode which this break statement is breaking from. This will be
|
| - * either a [Statement] (in the case of breaking out of a loop), a
|
| - * [SwitchMember] (in the case of a labeled break statement whose label
|
| - * matches a label on a switch case in an enclosing switch statement), or
|
| - * `null` if the AST has not yet been resolved or if the target could not be
|
| - * resolved. Note that if the source code has errors, the target might be
|
| - * invalid (e.g. trying to break to a switch case).
|
| - */
|
| - AstNode target;
|
| -
|
| - /**
|
| - * Initialize a newly created break statement. The [label] can be `null` if
|
| - * there is no label associated with the statement.
|
| - */
|
| - BreakStatement(this.breakKeyword, SimpleIdentifier label, this.semicolon) {
|
| - _label = _becomeParentOf(label);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => breakKeyword;
|
| -
|
| - @override
|
| - Iterable get childEntities =>
|
| - new ChildEntities()..add(breakKeyword)..add(_label)..add(semicolon);
|
| -
|
| - @override
|
| - Token get endToken => semicolon;
|
| -
|
| - /**
|
| - * Return the token representing the 'break' keyword.
|
| - */
|
| - @deprecated // Use "this.breakKeyword"
|
| - Token get keyword => breakKeyword;
|
| -
|
| - /**
|
| - * Sethe token representing the 'break' keyword to the given [token].
|
| - */
|
| - @deprecated // Use "this.breakKeyword"
|
| - void set keyword(Token token) {
|
| - breakKeyword = token;
|
| - }
|
| -
|
| - /**
|
| - * Return the label associated with the statement, or `null` if there is no
|
| - * label.
|
| - */
|
| - SimpleIdentifier get label => _label;
|
| -
|
| - /**
|
| - * Set the label associated with the statement to the given [identifier].
|
| - */
|
| - void set label(SimpleIdentifier identifier) {
|
| - _label = _becomeParentOf(identifier);
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitBreakStatement(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_label, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A sequence of cascaded expressions: expressions that share a common target.
|
| - * There are three kinds of expressions that can be used in a cascade
|
| - * expression: [IndexExpression], [MethodInvocation] and [PropertyAccess].
|
| - *
|
| - * > cascadeExpression ::=
|
| - * > [Expression] cascadeSection*
|
| - * >
|
| - * > cascadeSection ::=
|
| - * > '..' (cascadeSelector arguments*) (assignableSelector arguments*)*
|
| - * > (assignmentOperator expressionWithoutCascade)?
|
| - * >
|
| - * > cascadeSelector ::=
|
| - * > '[ ' expression '] '
|
| - * > | identifier
|
| - */
|
| -class CascadeExpression extends Expression {
|
| - /**
|
| - * The target of the cascade sections.
|
| - */
|
| - Expression _target;
|
| -
|
| - /**
|
| - * The cascade sections sharing the common target.
|
| - */
|
| - NodeList<Expression> _cascadeSections;
|
| -
|
| - /**
|
| - * Initialize a newly created cascade expression. The list of
|
| - * [cascadeSections] must contain at least one element.
|
| - */
|
| - CascadeExpression(Expression target, List<Expression> cascadeSections) {
|
| - _target = _becomeParentOf(target);
|
| - _cascadeSections = new NodeList<Expression>(this, cascadeSections);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => _target.beginToken;
|
| -
|
| - /**
|
| - * Return the cascade sections sharing the common target.
|
| - */
|
| - NodeList<Expression> get cascadeSections => _cascadeSections;
|
| -
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()
|
| - ..add(_target)
|
| - ..addAll(_cascadeSections);
|
| -
|
| - @override
|
| - Token get endToken => _cascadeSections.endToken;
|
| -
|
| - @override
|
| - int get precedence => 2;
|
| -
|
| - /**
|
| - * Return the target of the cascade sections.
|
| - */
|
| - Expression get target => _target;
|
| -
|
| - /**
|
| - * Set the target of the cascade sections to the given [expression].
|
| - */
|
| - void set target(Expression target) {
|
| - _target = _becomeParentOf(target);
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitCascadeExpression(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_target, visitor);
|
| - _cascadeSections.accept(visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A catch clause within a try statement.
|
| - *
|
| - * > onPart ::=
|
| - * > catchPart [Block]
|
| - * > | 'on' type catchPart? [Block]
|
| - * >
|
| - * > catchPart ::=
|
| - * > 'catch' '(' [SimpleIdentifier] (',' [SimpleIdentifier])? ')'
|
| - */
|
| -class CatchClause extends AstNode {
|
| - /**
|
| - * The token representing the 'on' keyword, or `null` if there is no 'on'
|
| - * keyword.
|
| - */
|
| - Token onKeyword;
|
| -
|
| - /**
|
| - * The type of exceptions caught by this catch clause, or `null` if this catch
|
| - * clause catches every type of exception.
|
| - */
|
| - TypeName _exceptionType;
|
| -
|
| - /**
|
| - * The token representing the 'catch' keyword, or `null` if there is no
|
| - * 'catch' keyword.
|
| - */
|
| - Token catchKeyword;
|
| -
|
| - /**
|
| - * The left parenthesis, or `null` if there is no 'catch' keyword.
|
| - */
|
| - Token leftParenthesis;
|
| -
|
| - /**
|
| - * The parameter whose value will be the exception that was thrown, or `null`
|
| - * if there is no 'catch' keyword.
|
| - */
|
| - SimpleIdentifier _exceptionParameter;
|
| -
|
| - /**
|
| - * The comma separating the exception parameter from the stack trace
|
| - * parameter, or `null` if there is no stack trace parameter.
|
| - */
|
| - Token comma;
|
| -
|
| - /**
|
| - * The parameter whose value will be the stack trace associated with the
|
| - * exception, or `null` if there is no stack trace parameter.
|
| - */
|
| - SimpleIdentifier _stackTraceParameter;
|
| -
|
| - /**
|
| - * The right parenthesis, or `null` if there is no 'catch' keyword.
|
| - */
|
| - Token rightParenthesis;
|
| -
|
| - /**
|
| - * The body of the catch block.
|
| - */
|
| - Block _body;
|
| -
|
| - /**
|
| - * Initialize a newly created catch clause. The [onKeyword] and
|
| - * [exceptionType] can be `null` if the clause will catch all exceptions. The
|
| - * [comma] and [stackTraceParameter] can be `null` if the stack trace is not
|
| - * referencable within the body.
|
| - */
|
| - CatchClause(this.onKeyword, TypeName exceptionType, this.catchKeyword,
|
| - this.leftParenthesis, SimpleIdentifier exceptionParameter, this.comma,
|
| - SimpleIdentifier stackTraceParameter, this.rightParenthesis, Block body) {
|
| - _exceptionType = _becomeParentOf(exceptionType);
|
| - _exceptionParameter = _becomeParentOf(exceptionParameter);
|
| - _stackTraceParameter = _becomeParentOf(stackTraceParameter);
|
| - _body = _becomeParentOf(body);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken {
|
| - if (onKeyword != null) {
|
| - return onKeyword;
|
| - }
|
| - return catchKeyword;
|
| - }
|
| -
|
| - /**
|
| - * Return the body of the catch block.
|
| - */
|
| - Block get body => _body;
|
| -
|
| - /**
|
| - * Set the body of the catch block to the given [block].
|
| - */
|
| - void set body(Block block) {
|
| - _body = _becomeParentOf(block);
|
| - }
|
| -
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()
|
| - ..add(onKeyword)
|
| - ..add(_exceptionType)
|
| - ..add(catchKeyword)
|
| - ..add(leftParenthesis)
|
| - ..add(_exceptionParameter)
|
| - ..add(comma)
|
| - ..add(_stackTraceParameter)
|
| - ..add(rightParenthesis)
|
| - ..add(_body);
|
| -
|
| - @override
|
| - Token get endToken => _body.endToken;
|
| -
|
| - /**
|
| - * Return the parameter whose value will be the exception that was thrown, or
|
| - * `null` if there is no 'catch' keyword.
|
| - */
|
| - SimpleIdentifier get exceptionParameter => _exceptionParameter;
|
| -
|
| - /**
|
| - * Set the parameter whose value will be the exception that was thrown to the
|
| - * given [parameter].
|
| - */
|
| - void set exceptionParameter(SimpleIdentifier parameter) {
|
| - _exceptionParameter = _becomeParentOf(parameter);
|
| - }
|
| -
|
| - /**
|
| - * Return the type of exceptions caught by this catch clause, or `null` if
|
| - * this catch clause catches every type of exception.
|
| - */
|
| - TypeName get exceptionType => _exceptionType;
|
| -
|
| - /**
|
| - * Set the type of exceptions caught by this catch clause to the given
|
| - * [exceptionType].
|
| - */
|
| - void set exceptionType(TypeName exceptionType) {
|
| - _exceptionType = _becomeParentOf(exceptionType);
|
| - }
|
| -
|
| - /**
|
| - * Return the parameter whose value will be the stack trace associated with
|
| - * the exception, or `null` if there is no stack trace parameter.
|
| - */
|
| - SimpleIdentifier get stackTraceParameter => _stackTraceParameter;
|
| -
|
| - /**
|
| - * Set the parameter whose value will be the stack trace associated with the
|
| - * exception to the given [parameter].
|
| - */
|
| - void set stackTraceParameter(SimpleIdentifier parameter) {
|
| - _stackTraceParameter = _becomeParentOf(parameter);
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitCatchClause(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_exceptionType, visitor);
|
| - _safelyVisitChild(_exceptionParameter, visitor);
|
| - _safelyVisitChild(_stackTraceParameter, visitor);
|
| - _safelyVisitChild(_body, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * Helper class to allow iteration of child entities of an AST node.
|
| - */
|
| -class ChildEntities extends Object with IterableMixin implements Iterable {
|
| - /**
|
| - * The list of child entities to be iterated over.
|
| - */
|
| - List _entities = [];
|
| -
|
| - @override
|
| - Iterator get iterator => _entities.iterator;
|
| -
|
| - /**
|
| - * Add an AST node or token as the next child entity, if it is not null.
|
| - */
|
| - void add(entity) {
|
| - if (entity != null) {
|
| - assert(entity is Token || entity is AstNode);
|
| - _entities.add(entity);
|
| - }
|
| - }
|
| -
|
| - /**
|
| - * Add the given items as the next child entities, if [items] is not null.
|
| - */
|
| - void addAll(Iterable items) {
|
| - if (items != null) {
|
| - _entities.addAll(items);
|
| - }
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * The declaration of a class.
|
| - *
|
| - * > classDeclaration ::=
|
| - * > 'abstract'? 'class' [SimpleIdentifier] [TypeParameterList]?
|
| - * > ([ExtendsClause] [WithClause]?)?
|
| - * > [ImplementsClause]?
|
| - * > '{' [ClassMember]* '}'
|
| - */
|
| -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 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;
|
| -
|
| - /**
|
| - * The with clause for the class, or `null` if the class does not have a with
|
| - * clause.
|
| - */
|
| - WithClause _withClause;
|
| -
|
| - /**
|
| - * The implements clause for the class, or `null` if the class does not
|
| - * implement any interfaces.
|
| - */
|
| - ImplementsClause _implementsClause;
|
| -
|
| - /**
|
| - * The native clause for the class, or `null` if the class does not have a
|
| - * native clause.
|
| - */
|
| - NativeClause _nativeClause;
|
| -
|
| - /**
|
| - * The left curly bracket.
|
| - */
|
| - Token leftBracket;
|
| -
|
| - /**
|
| - * The members defined by the class.
|
| - */
|
| - NodeList<ClassMember> _members;
|
| -
|
| - /**
|
| - * The right curly bracket.
|
| - */
|
| - Token rightBracket;
|
| -
|
| - /**
|
| - * Initialize a newly created class declaration. Either or both of the
|
| - * [comment] and [metadata] can be `null` if the class does not have the
|
| - * corresponding attribute. The [abstractKeyword] can be `null` if the class
|
| - * is not abstract. The [typeParameters] can be `null` if the class does not
|
| - * 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) {
|
| - _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)
|
| - ..add(classKeyword)
|
| - ..add(_name)
|
| - ..add(_typeParameters)
|
| - ..add(_extendsClause)
|
| - ..add(_withClause)
|
| - ..add(_implementsClause)
|
| - ..add(_nativeClause)
|
| - ..add(leftBracket)
|
| - ..addAll(members)
|
| - ..add(rightBracket);
|
| -
|
| - @override
|
| - ClassElement get element =>
|
| - _name != null ? (_name.staticElement as ClassElement) : null;
|
| -
|
| - @override
|
| - Token get endToken => rightBracket;
|
| -
|
| - /**
|
| - * Return the extends clause for this class, or `null` if the class does not
|
| - * extend any other class.
|
| - */
|
| - ExtendsClause get extendsClause => _extendsClause;
|
| -
|
| - /**
|
| - * Set the extends clause for this class to the given [extendsClause].
|
| - */
|
| - void set extendsClause(ExtendsClause extendsClause) {
|
| - _extendsClause = _becomeParentOf(extendsClause);
|
| - }
|
| -
|
| - @override
|
| - Token get firstTokenAfterCommentAndMetadata {
|
| - if (abstractKeyword != null) {
|
| - return abstractKeyword;
|
| - }
|
| - return classKeyword;
|
| - }
|
| -
|
| - /**
|
| - * Return the implements clause for the class, or `null` if the class does not
|
| - * implement any interfaces.
|
| - */
|
| - ImplementsClause get implementsClause => _implementsClause;
|
| -
|
| - /**
|
| - * Set the implements clause for the class to the given [implementsClause].
|
| - */
|
| - 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 members defined by the class.
|
| - */
|
| - NodeList<ClassMember> get members => _members;
|
| -
|
| - /**
|
| - * 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);
|
| - }
|
| -
|
| - /**
|
| - * Return the type parameters for the class, or `null` if the class does not
|
| - * have any type parameters.
|
| - */
|
| - TypeParameterList get typeParameters => _typeParameters;
|
| -
|
| - /**
|
| - * Set the type parameters for the class to the given list of [typeParameters].
|
| - */
|
| - void set typeParameters(TypeParameterList typeParameters) {
|
| - _typeParameters = _becomeParentOf(typeParameters);
|
| - }
|
| -
|
| - /**
|
| - * Return the with clause for the class, or `null` if the class does not have
|
| - * a with clause.
|
| - */
|
| - WithClause get withClause => _withClause;
|
| -
|
| - /**
|
| - * Set the with clause for the class to the given [withClause].
|
| - */
|
| - void set withClause(WithClause withClause) {
|
| - _withClause = _becomeParentOf(withClause);
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitClassDeclaration(this);
|
| -
|
| - /**
|
| - * Return the constructor declared in the class with the given [name], or
|
| - * `null` if there is no such constructor. If the [name] is `null` then the
|
| - * default constructor will be searched for.
|
| - */
|
| - ConstructorDeclaration getConstructor(String name) {
|
| - for (ClassMember classMember in _members) {
|
| - if (classMember is ConstructorDeclaration) {
|
| - ConstructorDeclaration constructor = classMember;
|
| - SimpleIdentifier constructorName = constructor.name;
|
| - if (name == null && constructorName == null) {
|
| - return constructor;
|
| - }
|
| - if (constructorName != null && constructorName.name == name) {
|
| - return constructor;
|
| - }
|
| - }
|
| - }
|
| - return null;
|
| - }
|
| -
|
| - /**
|
| - * Return the field declared in the class with the given [name], or `null` if
|
| - * there is no such field.
|
| - */
|
| - VariableDeclaration getField(String name) {
|
| - for (ClassMember classMember in _members) {
|
| - if (classMember is FieldDeclaration) {
|
| - FieldDeclaration fieldDeclaration = classMember;
|
| - NodeList<VariableDeclaration> fields =
|
| - fieldDeclaration.fields.variables;
|
| - for (VariableDeclaration field in fields) {
|
| - SimpleIdentifier fieldName = field.name;
|
| - if (fieldName != null && name == fieldName.name) {
|
| - return field;
|
| - }
|
| - }
|
| - }
|
| - }
|
| - return null;
|
| - }
|
| -
|
| - /**
|
| - * Return the method declared in the class with the given [name], or `null` if
|
| - * there is no such method.
|
| - */
|
| - MethodDeclaration getMethod(String name) {
|
| - for (ClassMember classMember in _members) {
|
| - if (classMember is MethodDeclaration) {
|
| - MethodDeclaration method = classMember;
|
| - SimpleIdentifier methodName = method.name;
|
| - if (methodName != null && name == methodName.name) {
|
| - return method;
|
| - }
|
| - }
|
| - }
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - super.visitChildren(visitor);
|
| - _safelyVisitChild(_name, visitor);
|
| - _safelyVisitChild(_typeParameters, visitor);
|
| - _safelyVisitChild(_extendsClause, visitor);
|
| - _safelyVisitChild(_withClause, visitor);
|
| - _safelyVisitChild(_implementsClause, visitor);
|
| - _safelyVisitChild(_nativeClause, visitor);
|
| - members.accept(visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A node that declares a name within the scope of a class.
|
| - */
|
| -abstract class ClassMember extends Declaration {
|
| - /**
|
| - * Initialize a newly created member of a class. Either or both of the
|
| - * [comment] and [metadata] can be `null` if the member does not have the
|
| - * corresponding attribute.
|
| - */
|
| - ClassMember(Comment comment, List<Annotation> metadata)
|
| - : super(comment, metadata);
|
| -}
|
| -
|
| -/**
|
| - * A class type alias.
|
| - *
|
| - * > classTypeAlias ::=
|
| - * > [SimpleIdentifier] [TypeParameterList]? '=' 'abstract'? mixinApplication
|
| - * >
|
| - * > mixinApplication ::=
|
| - * > [TypeName] [WithClause] [ImplementsClause]? ';'
|
| - */
|
| -class ClassTypeAlias extends TypeAlias {
|
| - /**
|
| - * 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;
|
| -
|
| - /**
|
| - * The token for the 'abstract' keyword, or `null` if this is not defining an
|
| - * abstract class.
|
| - */
|
| - Token abstractKeyword;
|
| -
|
| - /**
|
| - * The name of the superclass of the class being declared.
|
| - */
|
| - TypeName _superclass;
|
| -
|
| - /**
|
| - * The with clause for this class.
|
| - */
|
| - WithClause _withClause;
|
| -
|
| - /**
|
| - * The implements clause for this class, or `null` if there is no implements
|
| - * clause.
|
| - */
|
| - ImplementsClause _implementsClause;
|
| -
|
| - /**
|
| - * Initialize a newly created class type alias. Either or both of the
|
| - * [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, name, semicolon) {
|
| - _typeParameters = _becomeParentOf(typeParameters);
|
| - _superclass = _becomeParentOf(superclass);
|
| - _withClause = _becomeParentOf(withClause);
|
| - _implementsClause = _becomeParentOf(implementsClause);
|
| - }
|
| -
|
| - @override
|
| - Iterable get childEntities => super._childEntities
|
| - ..add(typedefKeyword)
|
| - ..add(_name)
|
| - ..add(_typeParameters)
|
| - ..add(equals)
|
| - ..add(abstractKeyword)
|
| - ..add(_superclass)
|
| - ..add(_withClause)
|
| - ..add(_implementsClause)
|
| - ..add(semicolon);
|
| -
|
| - @override
|
| - ClassElement get element =>
|
| - _name != null ? (_name.staticElement as ClassElement) : null;
|
| -
|
| - /**
|
| - * Return the implements clause for this class, or `null` if there is no
|
| - * implements clause.
|
| - */
|
| - ImplementsClause get implementsClause => _implementsClause;
|
| -
|
| - /**
|
| - * Set the implements clause for this class to the given [implementsClause].
|
| - */
|
| - 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 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);
|
| - }
|
| -
|
| - /**
|
| - * Return the type parameters for the class, or `null` if the class does not
|
| - * have any type parameters.
|
| - */
|
| - TypeParameterList get typeParameters => _typeParameters;
|
| -
|
| - /**
|
| - * Set the type parameters for the class to the given list of [typeParameters].
|
| - */
|
| - void set typeParameters(TypeParameterList typeParameters) {
|
| - _typeParameters = _becomeParentOf(typeParameters);
|
| - }
|
| -
|
| - /**
|
| - * Return the with clause for this class.
|
| - */
|
| - WithClause get withClause => _withClause;
|
| -
|
| - /**
|
| - * Set the with clause for this class to the given with [withClause].
|
| - */
|
| - void set withClause(WithClause withClause) {
|
| - _withClause = _becomeParentOf(withClause);
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitClassTypeAlias(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - super.visitChildren(visitor);
|
| - _safelyVisitChild(_name, visitor);
|
| - _safelyVisitChild(_typeParameters, visitor);
|
| - _safelyVisitChild(_superclass, visitor);
|
| - _safelyVisitChild(_withClause, visitor);
|
| - _safelyVisitChild(_implementsClause, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A combinator associated with an import or export directive.
|
| - *
|
| - * > combinator ::=
|
| - * > [HideCombinator]
|
| - * > | [ShowCombinator]
|
| - */
|
| -abstract class Combinator extends AstNode {
|
| - /**
|
| - * The 'hide' or 'show' keyword specifying what kind of processing is to be
|
| - * done on the names.
|
| - */
|
| - Token keyword;
|
| -
|
| - /**
|
| - * Initialize a newly created combinator.
|
| - */
|
| - Combinator(this.keyword);
|
| -
|
| - @override
|
| - Token get beginToken => keyword;
|
| -}
|
| -
|
| -/**
|
| - * A comment within the source code.
|
| - *
|
| - * > comment ::=
|
| - * > endOfLineComment
|
| - * > | blockComment
|
| - * > | documentationComment
|
| - * >
|
| - * > endOfLineComment ::=
|
| - * > '//' (CHARACTER - EOL)* EOL
|
| - * >
|
| - * > blockComment ::=
|
| - * > '/ *' CHARACTER* '*/'
|
| - * >
|
| - * > documentationComment ::=
|
| - * > '/ **' (CHARACTER | [CommentReference])* '*/'
|
| - * > | ('///' (CHARACTER - EOL)* EOL)+
|
| - */
|
| -class Comment extends AstNode {
|
| - /**
|
| - * The tokens representing the comment.
|
| - */
|
| - final List<Token> tokens;
|
| -
|
| - /**
|
| - * The type of the comment.
|
| - */
|
| - final CommentType _type;
|
| -
|
| - /**
|
| - * The references embedded within the documentation comment. This list will be
|
| - * empty unless this is a documentation comment that has references embedded
|
| - * within it.
|
| - */
|
| - NodeList<CommentReference> _references;
|
| -
|
| - /**
|
| - * Initialize a newly created comment. The list of [tokens] must contain at
|
| - * least one token. The [type] is the type of the comment. The list of
|
| - * [references] can be empty if the comment does not contain any embedded
|
| - * references.
|
| - */
|
| - Comment(this.tokens, this._type, List<CommentReference> references) {
|
| - _references = new NodeList<CommentReference>(this, references);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => tokens[0];
|
| -
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()..addAll(tokens);
|
| -
|
| - @override
|
| - Token get endToken => tokens[tokens.length - 1];
|
| -
|
| - /**
|
| - * Return `true` if this is a block comment.
|
| - */
|
| - bool get isBlock => _type == CommentType.BLOCK;
|
| -
|
| - /**
|
| - * Return `true` if this is a documentation comment.
|
| - */
|
| - bool get isDocumentation => _type == CommentType.DOCUMENTATION;
|
| -
|
| - /**
|
| - * Return `true` if this is an end-of-line comment.
|
| - */
|
| - bool get isEndOfLine => _type == CommentType.END_OF_LINE;
|
| -
|
| - /**
|
| - * Return the references embedded within the documentation comment.
|
| - */
|
| - NodeList<CommentReference> get references => _references;
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitComment(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _references.accept(visitor);
|
| - }
|
| -
|
| - /**
|
| - * Create a block comment consisting of the given [tokens].
|
| - */
|
| - static Comment createBlockComment(List<Token> tokens) =>
|
| - new Comment(tokens, CommentType.BLOCK, null);
|
| -
|
| - /**
|
| - * Create a documentation comment consisting of the given [tokens].
|
| - */
|
| - static Comment createDocumentationComment(List<Token> tokens) => new Comment(
|
| - tokens, CommentType.DOCUMENTATION, new List<CommentReference>());
|
| -
|
| - /**
|
| - * Create a documentation comment consisting of the given [tokens] and having
|
| - * the given [references] embedded within it.
|
| - */
|
| - static Comment createDocumentationCommentWithReferences(
|
| - List<Token> tokens, List<CommentReference> references) =>
|
| - new Comment(tokens, CommentType.DOCUMENTATION, references);
|
| -
|
| - /**
|
| - * Create an end-of-line comment consisting of the given [tokens].
|
| - */
|
| - static Comment createEndOfLineComment(List<Token> tokens) =>
|
| - new Comment(tokens, CommentType.END_OF_LINE, null);
|
| -}
|
| -
|
| -/**
|
| - * A reference to a Dart element that is found within a documentation comment.
|
| - *
|
| - * > commentReference ::=
|
| - * > '[' 'new'? [Identifier] ']'
|
| - */
|
| -class CommentReference extends AstNode {
|
| - /**
|
| - * The token representing the 'new' keyword, or `null` if there was no 'new'
|
| - * keyword.
|
| - */
|
| - Token newKeyword;
|
| -
|
| - /**
|
| - * The identifier being referenced.
|
| - */
|
| - Identifier _identifier;
|
| -
|
| - /**
|
| - * Initialize a newly created reference to a Dart element. The [newKeyword]
|
| - * can be `null` if the reference is not to a constructor.
|
| - */
|
| - CommentReference(this.newKeyword, Identifier identifier) {
|
| - _identifier = _becomeParentOf(identifier);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => _identifier.beginToken;
|
| -
|
| - @override
|
| - Iterable get childEntities =>
|
| - new ChildEntities()..add(newKeyword)..add(_identifier);
|
| -
|
| - @override
|
| - Token get endToken => _identifier.endToken;
|
| -
|
| - /**
|
| - * Return the identifier being referenced.
|
| - */
|
| - Identifier get identifier => _identifier;
|
| -
|
| - /**
|
| - * Set the identifier being referenced to the given [identifier].
|
| - */
|
| - void set identifier(Identifier identifier) {
|
| - _identifier = _becomeParentOf(identifier);
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitCommentReference(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_identifier, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * The possible types of comments that are recognized by the parser.
|
| - */
|
| -class CommentType {
|
| - /**
|
| - * A block comment.
|
| - */
|
| - static const CommentType BLOCK = const CommentType('BLOCK');
|
| -
|
| - /**
|
| - * A documentation comment.
|
| - */
|
| - static const CommentType DOCUMENTATION = const CommentType('DOCUMENTATION');
|
| -
|
| - /**
|
| - * An end-of-line comment.
|
| - */
|
| - static const CommentType END_OF_LINE = const CommentType('END_OF_LINE');
|
| -
|
| - /**
|
| - * The name of the comment type.
|
| - */
|
| - final String name;
|
| -
|
| - /**
|
| - * Initialize a newly created comment type to have the given [name].
|
| - */
|
| - const CommentType(this.name);
|
| -
|
| - @override
|
| - String toString() => name;
|
| -}
|
| -
|
| -/**
|
| - * A compilation unit.
|
| - *
|
| - * While the grammar restricts the order of the directives and declarations
|
| - * within a compilation unit, this class does not enforce those restrictions.
|
| - * In particular, the children of a compilation unit will be visited in lexical
|
| - * order even if lexical order does not conform to the restrictions of the
|
| - * grammar.
|
| - *
|
| - * > compilationUnit ::=
|
| - * > directives declarations
|
| - * >
|
| - * > directives ::=
|
| - * > [ScriptTag]? [LibraryDirective]? namespaceDirective* [PartDirective]*
|
| - * > | [PartOfDirective]
|
| - * >
|
| - * > namespaceDirective ::=
|
| - * > [ImportDirective]
|
| - * > | [ExportDirective]
|
| - * >
|
| - * > declarations ::=
|
| - * > [CompilationUnitMember]*
|
| - */
|
| -class CompilationUnit extends AstNode {
|
| - /**
|
| - * The first token in the token stream that was parsed to form this
|
| - * compilation unit.
|
| - */
|
| - Token beginToken;
|
| -
|
| - /**
|
| - * The script tag at the beginning of the compilation unit, or `null` if there
|
| - * is no script tag in this compilation unit.
|
| - */
|
| - ScriptTag _scriptTag;
|
| -
|
| - /**
|
| - * The directives contained in this compilation unit.
|
| - */
|
| - NodeList<Directive> _directives;
|
| -
|
| - /**
|
| - * The declarations contained in this compilation unit.
|
| - */
|
| - NodeList<CompilationUnitMember> _declarations;
|
| -
|
| - /**
|
| - * The last token in the token stream that was parsed to form this compilation
|
| - * unit. This token should always have a type of [TokenType.EOF].
|
| - */
|
| - Token endToken;
|
| -
|
| - /**
|
| - * The element associated with this compilation unit, or `null` if the AST
|
| - * structure has not been resolved.
|
| - */
|
| - CompilationUnitElement element;
|
| -
|
| - /**
|
| - * The line information for this compilation unit.
|
| - */
|
| - LineInfo lineInfo;
|
| -
|
| - /**
|
| - * Initialize a newly created compilation unit to have the given directives
|
| - * and declarations. The [scriptTag] can be `null` if there is no script tag
|
| - * in the compilation unit. The list of [directives] can be `null` if there
|
| - * are no directives in the compilation unit. The list of [declarations] can
|
| - * be `null` if there are no declarations in the compilation unit.
|
| - */
|
| - CompilationUnit(this.beginToken, ScriptTag scriptTag,
|
| - List<Directive> directives, List<CompilationUnitMember> declarations,
|
| - this.endToken) {
|
| - _scriptTag = _becomeParentOf(scriptTag);
|
| - _directives = new NodeList<Directive>(this, directives);
|
| - _declarations = new NodeList<CompilationUnitMember>(this, declarations);
|
| - }
|
| -
|
| - @override
|
| - Iterable get childEntities {
|
| - ChildEntities result = new ChildEntities()..add(_scriptTag);
|
| - if (_directivesAreBeforeDeclarations) {
|
| - result..addAll(_directives)..addAll(_declarations);
|
| - } else {
|
| - result.addAll(sortedDirectivesAndDeclarations);
|
| - }
|
| - return result;
|
| - }
|
| -
|
| - /**
|
| - * Return the declarations contained in this compilation unit.
|
| - */
|
| - NodeList<CompilationUnitMember> get declarations => _declarations;
|
| -
|
| - /**
|
| - * Return the directives contained in this compilation unit.
|
| - */
|
| - NodeList<Directive> get directives => _directives;
|
| -
|
| - @override
|
| - int get length {
|
| - Token endToken = this.endToken;
|
| - if (endToken == null) {
|
| - return 0;
|
| - }
|
| - return endToken.offset + endToken.length;
|
| - }
|
| -
|
| - @override
|
| - int get offset => 0;
|
| -
|
| - /**
|
| - * Return the script tag at the beginning of the compilation unit, or `null`
|
| - * if there is no script tag in this compilation unit.
|
| - */
|
| - ScriptTag get scriptTag => _scriptTag;
|
| -
|
| - /**
|
| - * Set the script tag at the beginning of the compilation unit to the given
|
| - * [scriptTag].
|
| - */
|
| - void set scriptTag(ScriptTag scriptTag) {
|
| - _scriptTag = _becomeParentOf(scriptTag);
|
| - }
|
| -
|
| - /**
|
| - * Return a list containing all of the directives and declarations in this
|
| - * compilation unit, sorted in lexical order.
|
| - */
|
| - List<AstNode> get sortedDirectivesAndDeclarations {
|
| - return <AstNode>[]
|
| - ..addAll(_directives)
|
| - ..addAll(_declarations)
|
| - ..sort(AstNode.LEXICAL_ORDER);
|
| - }
|
| -
|
| - /**
|
| - * Return `true` if all of the directives are lexically before any
|
| - * declarations.
|
| - */
|
| - bool get _directivesAreBeforeDeclarations {
|
| - if (_directives.isEmpty || _declarations.isEmpty) {
|
| - return true;
|
| - }
|
| - Directive lastDirective = _directives[_directives.length - 1];
|
| - CompilationUnitMember firstDeclaration = _declarations[0];
|
| - return lastDirective.offset < firstDeclaration.offset;
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitCompilationUnit(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_scriptTag, visitor);
|
| - if (_directivesAreBeforeDeclarations) {
|
| - _directives.accept(visitor);
|
| - _declarations.accept(visitor);
|
| - } else {
|
| - for (AstNode child in sortedDirectivesAndDeclarations) {
|
| - child.accept(visitor);
|
| - }
|
| - }
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * 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 {
|
| - /**
|
| - * Initialize a newly created generic compilation unit member. Either or both
|
| - * of the [comment] and [metadata] can be `null` if the member does not have
|
| - * the corresponding attribute.
|
| - */
|
| - CompilationUnitMember(Comment comment, List<Annotation> metadata)
|
| - : super(comment, metadata);
|
| -}
|
| -
|
| -/**
|
| - * A conditional expression.
|
| - *
|
| - * > conditionalExpression ::=
|
| - * > [Expression] '?' [Expression] ':' [Expression]
|
| - */
|
| -class ConditionalExpression extends Expression {
|
| - /**
|
| - * The condition used to determine which of the expressions is executed next.
|
| - */
|
| - Expression _condition;
|
| -
|
| - /**
|
| - * The token used to separate the condition from the then expression.
|
| - */
|
| - Token question;
|
| -
|
| - /**
|
| - * The expression that is executed if the condition evaluates to `true`.
|
| - */
|
| - Expression _thenExpression;
|
| -
|
| - /**
|
| - * The token used to separate the then expression from the else expression.
|
| - */
|
| - Token colon;
|
| -
|
| - /**
|
| - * The expression that is executed if the condition evaluates to `false`.
|
| - */
|
| - Expression _elseExpression;
|
| -
|
| - /**
|
| - * Initialize a newly created conditional expression.
|
| - */
|
| - ConditionalExpression(Expression condition, this.question,
|
| - Expression thenExpression, this.colon, Expression elseExpression) {
|
| - _condition = _becomeParentOf(condition);
|
| - _thenExpression = _becomeParentOf(thenExpression);
|
| - _elseExpression = _becomeParentOf(elseExpression);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => _condition.beginToken;
|
| -
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()
|
| - ..add(_condition)
|
| - ..add(question)
|
| - ..add(_thenExpression)
|
| - ..add(colon)
|
| - ..add(_elseExpression);
|
| -
|
| - /**
|
| - * Return the condition used to determine which of the expressions is executed
|
| - * next.
|
| - */
|
| - Expression get condition => _condition;
|
| -
|
| - /**
|
| - * Set the condition used to determine which of the expressions is executed
|
| - * next to the given [expression].
|
| - */
|
| - void set condition(Expression expression) {
|
| - _condition = _becomeParentOf(expression);
|
| - }
|
| -
|
| - /**
|
| - * Return the expression that is executed if the condition evaluates to
|
| - * `false`.
|
| - */
|
| - Expression get elseExpression => _elseExpression;
|
| -
|
| - /**
|
| - * Set the expression that is executed if the condition evaluates to `false`
|
| - * to the given [expression].
|
| - */
|
| - void set elseExpression(Expression expression) {
|
| - _elseExpression = _becomeParentOf(expression);
|
| - }
|
| -
|
| - @override
|
| - Token get endToken => _elseExpression.endToken;
|
| -
|
| - @override
|
| - int get precedence => 3;
|
| -
|
| - /**
|
| - * Return the expression that is executed if the condition evaluates to
|
| - * `true`.
|
| - */
|
| - Expression get thenExpression => _thenExpression;
|
| -
|
| - /**
|
| - * Set the expression that is executed if the condition evaluates to `true` to
|
| - * the given [expression].
|
| - */
|
| - void set thenExpression(Expression expression) {
|
| - _thenExpression = _becomeParentOf(expression);
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitConditionalExpression(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_condition, visitor);
|
| - _safelyVisitChild(_thenExpression, visitor);
|
| - _safelyVisitChild(_elseExpression, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * An object that can be used to evaluate constant expressions to produce their
|
| - * compile-time value. According to the Dart Language Specification:
|
| - * <blockquote>
|
| - * A constant expression is one of the following:
|
| - * * A literal number.
|
| - * * A literal boolean.
|
| - * * A literal string where any interpolated expression is a compile-time
|
| - * constant that evaluates to a numeric, string or boolean value or to `null`.
|
| - * * `null`.
|
| - * * A reference to a static constant variable.
|
| - * * An identifier expression that denotes a constant variable, a class or a
|
| - * type parameter.
|
| - * * A constant constructor invocation.
|
| - * * A constant list literal.
|
| - * * A constant map literal.
|
| - * * A simple or qualified identifier denoting a top-level function or a static
|
| - * method.
|
| - * * A parenthesized expression `(e)` where `e` is a constant expression.
|
| - * * An expression of one of the forms `identical(e1, e2)`, `e1 == e2`,
|
| - * `e1 != e2` where `e1` and `e2` are constant expressions that evaluate to a
|
| - * numeric, string or boolean value or to `null`.
|
| - * * An expression of one of the forms `!e`, `e1 && e2` or `e1 || e2`, where
|
| - * `e`, `e1` and `e2` are constant expressions that evaluate to a boolean
|
| - * value or to `null`.
|
| - * * An expression of one of the forms `~e`, `e1 ^ e2`, `e1 & e2`, `e1 | e2`,
|
| - * `e1 >> e2` or `e1 << e2`, where `e`, `e1` and `e2` are constant expressions
|
| - * that evaluate to an integer value or to `null`.
|
| - * * An expression of one of the forms `-e`, `e1 + e2`, `e1 - e2`, `e1 * e2`,
|
| - * `e1 / e2`, `e1 ~/ e2`, `e1 > e2`, `e1 < e2`, `e1 >= e2`, `e1 <= e2` or
|
| - * `e1 % e2`, where `e`, `e1` and `e2` are constant expressions that evaluate
|
| - * to a numeric value or to `null`.
|
| - * </blockquote>
|
| - * The values returned by instances of this class are therefore `null` and
|
| - * instances of the classes `Boolean`, `BigInteger`, `Double`, `String`, and
|
| - * `DartObject`.
|
| - *
|
| - * In addition, this class defines several values that can be returned to
|
| - * indicate various conditions encountered during evaluation. These are
|
| - * documented with the static fields that define those values.
|
| - */
|
| -class ConstantEvaluator extends GeneralizingAstVisitor<Object> {
|
| - /**
|
| - * The value returned for expressions (or non-expression nodes) that are not
|
| - * compile-time constant expressions.
|
| - */
|
| - static Object NOT_A_CONSTANT = new Object();
|
| -
|
| - @override
|
| - Object visitAdjacentStrings(AdjacentStrings node) {
|
| - StringBuffer buffer = new StringBuffer();
|
| - for (StringLiteral string in node.strings) {
|
| - Object value = string.accept(this);
|
| - if (identical(value, NOT_A_CONSTANT)) {
|
| - return value;
|
| - }
|
| - buffer.write(value);
|
| - }
|
| - return buffer.toString();
|
| - }
|
| -
|
| - @override
|
| - Object visitBinaryExpression(BinaryExpression node) {
|
| - Object leftOperand = node.leftOperand.accept(this);
|
| - if (identical(leftOperand, NOT_A_CONSTANT)) {
|
| - return leftOperand;
|
| - }
|
| - Object rightOperand = node.rightOperand.accept(this);
|
| - if (identical(rightOperand, NOT_A_CONSTANT)) {
|
| - return rightOperand;
|
| - }
|
| - while (true) {
|
| - if (node.operator.type == TokenType.AMPERSAND) {
|
| - // integer or {@code null}
|
| - if (leftOperand is int && rightOperand is int) {
|
| - return leftOperand & rightOperand;
|
| - }
|
| - } else if (node.operator.type == TokenType.AMPERSAND_AMPERSAND) {
|
| - // boolean or {@code null}
|
| - if (leftOperand is bool && rightOperand is bool) {
|
| - return leftOperand && rightOperand;
|
| - }
|
| - } else if (node.operator.type == TokenType.BANG_EQ) {
|
| - // numeric, string, boolean, or {@code null}
|
| - if (leftOperand is bool && rightOperand is bool) {
|
| - return leftOperand != rightOperand;
|
| - } else if (leftOperand is num && rightOperand is num) {
|
| - return leftOperand != rightOperand;
|
| - } else if (leftOperand is String && rightOperand is String) {
|
| - return leftOperand != rightOperand;
|
| - }
|
| - } else if (node.operator.type == TokenType.BAR) {
|
| - // integer or {@code null}
|
| - if (leftOperand is int && rightOperand is int) {
|
| - return leftOperand | rightOperand;
|
| - }
|
| - } else if (node.operator.type == TokenType.BAR_BAR) {
|
| - // boolean or {@code null}
|
| - if (leftOperand is bool && rightOperand is bool) {
|
| - return leftOperand || rightOperand;
|
| - }
|
| - } else if (node.operator.type == TokenType.CARET) {
|
| - // integer or {@code null}
|
| - if (leftOperand is int && rightOperand is int) {
|
| - return leftOperand ^ rightOperand;
|
| - }
|
| - } else if (node.operator.type == TokenType.EQ_EQ) {
|
| - // numeric, string, boolean, or {@code null}
|
| - if (leftOperand is bool && rightOperand is bool) {
|
| - return leftOperand == rightOperand;
|
| - } else if (leftOperand is num && rightOperand is num) {
|
| - return leftOperand == rightOperand;
|
| - } else if (leftOperand is String && rightOperand is String) {
|
| - return leftOperand == rightOperand;
|
| - }
|
| - } else if (node.operator.type == TokenType.GT) {
|
| - // numeric or {@code null}
|
| - if (leftOperand is num && rightOperand is num) {
|
| - return leftOperand.compareTo(rightOperand) > 0;
|
| - }
|
| - } else if (node.operator.type == TokenType.GT_EQ) {
|
| - // numeric or {@code null}
|
| - if (leftOperand is num && rightOperand is num) {
|
| - return leftOperand.compareTo(rightOperand) >= 0;
|
| - }
|
| - } else if (node.operator.type == TokenType.GT_GT) {
|
| - // integer or {@code null}
|
| - if (leftOperand is int && rightOperand is int) {
|
| - return leftOperand >> rightOperand;
|
| - }
|
| - } else if (node.operator.type == TokenType.LT) {
|
| - // numeric or {@code null}
|
| - if (leftOperand is num && rightOperand is num) {
|
| - return leftOperand.compareTo(rightOperand) < 0;
|
| - }
|
| - } else if (node.operator.type == TokenType.LT_EQ) {
|
| - // numeric or {@code null}
|
| - if (leftOperand is num && rightOperand is num) {
|
| - return leftOperand.compareTo(rightOperand) <= 0;
|
| - }
|
| - } else if (node.operator.type == TokenType.LT_LT) {
|
| - // integer or {@code null}
|
| - if (leftOperand is int && rightOperand is int) {
|
| - return leftOperand << rightOperand;
|
| - }
|
| - } else if (node.operator.type == TokenType.MINUS) {
|
| - // numeric or {@code null}
|
| - if (leftOperand is num && rightOperand is num) {
|
| - return leftOperand - rightOperand;
|
| - }
|
| - } else if (node.operator.type == TokenType.PERCENT) {
|
| - // numeric or {@code null}
|
| - if (leftOperand is num && rightOperand is num) {
|
| - return leftOperand.remainder(rightOperand);
|
| - }
|
| - } else if (node.operator.type == TokenType.PLUS) {
|
| - // numeric or {@code null}
|
| - if (leftOperand is num && rightOperand is num) {
|
| - return leftOperand + rightOperand;
|
| - }
|
| - } else if (node.operator.type == TokenType.STAR) {
|
| - // numeric or {@code null}
|
| - if (leftOperand is num && rightOperand is num) {
|
| - return leftOperand * rightOperand;
|
| - }
|
| - } else if (node.operator.type == TokenType.SLASH) {
|
| - // numeric or {@code null}
|
| - if (leftOperand is num && rightOperand is num) {
|
| - return leftOperand / rightOperand;
|
| - }
|
| - } else if (node.operator.type == TokenType.TILDE_SLASH) {
|
| - // numeric or {@code null}
|
| - if (leftOperand is num && rightOperand is num) {
|
| - return leftOperand ~/ rightOperand;
|
| - }
|
| - } else {}
|
| - break;
|
| - }
|
| - // TODO(brianwilkerson) This doesn't handle numeric conversions.
|
| - return visitExpression(node);
|
| - }
|
| -
|
| - @override
|
| - Object visitBooleanLiteral(BooleanLiteral node) => node.value ? true : false;
|
| -
|
| - @override
|
| - Object visitDoubleLiteral(DoubleLiteral node) => node.value;
|
| -
|
| - @override
|
| - Object visitIntegerLiteral(IntegerLiteral node) => node.value;
|
| -
|
| - @override
|
| - Object visitInterpolationExpression(InterpolationExpression node) {
|
| - Object value = node.expression.accept(this);
|
| - if (value == null || value is bool || value is String || value is num) {
|
| - return value;
|
| - }
|
| - return NOT_A_CONSTANT;
|
| - }
|
| -
|
| - @override
|
| - Object visitInterpolationString(InterpolationString node) => node.value;
|
| -
|
| - @override
|
| - Object visitListLiteral(ListLiteral node) {
|
| - List<Object> list = new List<Object>();
|
| - for (Expression element in node.elements) {
|
| - Object value = element.accept(this);
|
| - if (identical(value, NOT_A_CONSTANT)) {
|
| - return value;
|
| - }
|
| - list.add(value);
|
| - }
|
| - return list;
|
| - }
|
| -
|
| - @override
|
| - Object visitMapLiteral(MapLiteral node) {
|
| - HashMap<String, Object> map = new HashMap<String, Object>();
|
| - for (MapLiteralEntry entry in node.entries) {
|
| - Object key = entry.key.accept(this);
|
| - Object value = entry.value.accept(this);
|
| - if (key is! String || identical(value, NOT_A_CONSTANT)) {
|
| - return NOT_A_CONSTANT;
|
| - }
|
| - map[(key as String)] = value;
|
| - }
|
| - return map;
|
| - }
|
| -
|
| - @override
|
| - Object visitMethodInvocation(MethodInvocation node) => visitNode(node);
|
| -
|
| - @override
|
| - Object visitNode(AstNode node) => NOT_A_CONSTANT;
|
| -
|
| - @override
|
| - Object visitNullLiteral(NullLiteral node) => null;
|
| -
|
| - @override
|
| - Object visitParenthesizedExpression(ParenthesizedExpression node) =>
|
| - node.expression.accept(this);
|
| -
|
| - @override
|
| - Object visitPrefixedIdentifier(PrefixedIdentifier node) =>
|
| - _getConstantValue(null);
|
| -
|
| - @override
|
| - Object visitPrefixExpression(PrefixExpression node) {
|
| - Object operand = node.operand.accept(this);
|
| - if (identical(operand, NOT_A_CONSTANT)) {
|
| - return operand;
|
| - }
|
| - while (true) {
|
| - if (node.operator.type == TokenType.BANG) {
|
| - if (identical(operand, true)) {
|
| - return false;
|
| - } else if (identical(operand, false)) {
|
| - return true;
|
| - }
|
| - } else if (node.operator.type == TokenType.TILDE) {
|
| - if (operand is int) {
|
| - return ~operand;
|
| - }
|
| - } else if (node.operator.type == TokenType.MINUS) {
|
| - if (operand == null) {
|
| - return null;
|
| - } else if (operand is num) {
|
| - return -operand;
|
| - }
|
| - } else {}
|
| - break;
|
| - }
|
| - return NOT_A_CONSTANT;
|
| - }
|
| -
|
| - @override
|
| - Object visitPropertyAccess(PropertyAccess node) => _getConstantValue(null);
|
| -
|
| - @override
|
| - Object visitSimpleIdentifier(SimpleIdentifier node) =>
|
| - _getConstantValue(null);
|
| -
|
| - @override
|
| - Object visitSimpleStringLiteral(SimpleStringLiteral node) => node.value;
|
| -
|
| - @override
|
| - Object visitStringInterpolation(StringInterpolation node) {
|
| - StringBuffer buffer = new StringBuffer();
|
| - for (InterpolationElement element in node.elements) {
|
| - Object value = element.accept(this);
|
| - if (identical(value, NOT_A_CONSTANT)) {
|
| - return value;
|
| - }
|
| - buffer.write(value);
|
| - }
|
| - return buffer.toString();
|
| - }
|
| -
|
| - @override
|
| - Object visitSymbolLiteral(SymbolLiteral node) {
|
| - // TODO(brianwilkerson) This isn't optimal because a Symbol is not a String.
|
| - StringBuffer buffer = new StringBuffer();
|
| - for (Token component in node.components) {
|
| - if (buffer.length > 0) {
|
| - buffer.writeCharCode(0x2E);
|
| - }
|
| - buffer.write(component.lexeme);
|
| - }
|
| - return buffer.toString();
|
| - }
|
| -
|
| - /**
|
| - * Return the constant value of the static constant represented by the given
|
| - * [element].
|
| - */
|
| - Object _getConstantValue(Element element) {
|
| - // TODO(brianwilkerson) Implement this
|
| - if (element is FieldElement) {
|
| - FieldElement field = element;
|
| - if (field.isStatic && field.isConst) {
|
| - //field.getConstantValue();
|
| - }
|
| - // } else if (element instanceof VariableElement) {
|
| - // VariableElement variable = (VariableElement) element;
|
| - // if (variable.isStatic() && variable.isConst()) {
|
| - // //variable.getConstantValue();
|
| - // }
|
| - }
|
| - return NOT_A_CONSTANT;
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A constructor declaration.
|
| - *
|
| - * > constructorDeclaration ::=
|
| - * > constructorSignature [FunctionBody]?
|
| - * > | constructorName formalParameterList ':' 'this' ('.' [SimpleIdentifier])? arguments
|
| - * >
|
| - * > constructorSignature ::=
|
| - * > 'external'? constructorName formalParameterList initializerList?
|
| - * > | 'external'? 'factory' factoryName formalParameterList initializerList?
|
| - * > | 'external'? 'const' constructorName formalParameterList initializerList?
|
| - * >
|
| - * > constructorName ::=
|
| - * > [SimpleIdentifier] ('.' [SimpleIdentifier])?
|
| - * >
|
| - * > factoryName ::=
|
| - * > [Identifier] ('.' [SimpleIdentifier])?
|
| - * >
|
| - * > initializerList ::=
|
| - * > ':' [ConstructorInitializer] (',' [ConstructorInitializer])*
|
| - */
|
| -class ConstructorDeclaration extends ClassMember {
|
| - /**
|
| - * The token for the 'external' keyword, or `null` if the constructor is not
|
| - * external.
|
| - */
|
| - Token externalKeyword;
|
| -
|
| - /**
|
| - * The token for the 'const' keyword, or `null` if the constructor is not a
|
| - * const constructor.
|
| - */
|
| - Token constKeyword;
|
| -
|
| - /**
|
| - * The token for the 'factory' keyword, or `null` if the constructor is not a
|
| - * factory constructor.
|
| - */
|
| - Token factoryKeyword;
|
| -
|
| - /**
|
| - * The type of object being created. This can be different than the type in
|
| - * which the constructor is being declared if the constructor is the
|
| - * implementation of a factory constructor.
|
| - */
|
| - Identifier _returnType;
|
| -
|
| - /**
|
| - * The token for the period before the constructor name, or `null` if the
|
| - * constructor being declared is unnamed.
|
| - */
|
| - Token period;
|
| -
|
| - /**
|
| - * The name of the constructor, or `null` if the constructor being declared is
|
| - * unnamed.
|
| - */
|
| - SimpleIdentifier _name;
|
| -
|
| - /**
|
| - * The parameters associated with the constructor.
|
| - */
|
| - FormalParameterList _parameters;
|
| -
|
| - /**
|
| - * The token for the separator (colon or equals) before the initializer list
|
| - * or redirection, or `null` if there are no initializers.
|
| - */
|
| - Token separator;
|
| -
|
| - /**
|
| - * The initializers associated with the constructor.
|
| - */
|
| - NodeList<ConstructorInitializer> _initializers;
|
| -
|
| - /**
|
| - * The name of the constructor to which this constructor will be redirected,
|
| - * or `null` if this is not a redirecting factory constructor.
|
| - */
|
| - ConstructorName _redirectedConstructor;
|
| -
|
| - /**
|
| - * The body of the constructor, or `null` if the constructor does not have a
|
| - * body.
|
| - */
|
| - FunctionBody _body;
|
| -
|
| - /**
|
| - * The element associated with this constructor, or `null` if the AST
|
| - * structure has not been resolved or if this constructor could not be
|
| - * resolved.
|
| - */
|
| - ConstructorElement element;
|
| -
|
| - /**
|
| - * Initialize a newly created constructor declaration. The [externalKeyword]
|
| - * can be `null` if the constructor is not external. Either or both of the
|
| - * [comment] and [metadata] can be `null` if the constructor does not have the
|
| - * corresponding attribute. The [constKeyword] can be `null` if the
|
| - * constructor cannot be used to create a constant. The [factoryKeyword] can
|
| - * be `null` if the constructor is not a factory. The [period] and [name] can
|
| - * both be `null` if the constructor is not a named constructor. The
|
| - * [separator] can be `null` if the constructor does not have any initializers
|
| - * and does not redirect to a different constructor. The list of
|
| - * [initializers] can be `null` if the constructor does not have any
|
| - * initializers. The [redirectedConstructor] can be `null` if the constructor
|
| - * does not redirect to a different constructor. The [body] can be `null` if
|
| - * the constructor does not have a body.
|
| - */
|
| - ConstructorDeclaration(Comment comment, List<Annotation> metadata,
|
| - this.externalKeyword, this.constKeyword, this.factoryKeyword,
|
| - Identifier returnType, this.period, SimpleIdentifier name,
|
| - FormalParameterList parameters, this.separator,
|
| - List<ConstructorInitializer> initializers,
|
| - ConstructorName redirectedConstructor, FunctionBody body)
|
| - : super(comment, metadata) {
|
| - _returnType = _becomeParentOf(returnType);
|
| - _name = _becomeParentOf(name);
|
| - _parameters = _becomeParentOf(parameters);
|
| - _initializers = new NodeList<ConstructorInitializer>(this, initializers);
|
| - _redirectedConstructor = _becomeParentOf(redirectedConstructor);
|
| - _body = _becomeParentOf(body);
|
| - }
|
| -
|
| - /**
|
| - * Return the body of the constructor, or `null` if the constructor does not
|
| - * have a body.
|
| - */
|
| - FunctionBody get body => _body;
|
| -
|
| - /**
|
| - * Set the body of the constructor to the given [functionBody].
|
| - */
|
| - void set body(FunctionBody functionBody) {
|
| - _body = _becomeParentOf(functionBody);
|
| - }
|
| -
|
| - @override
|
| - Iterable get childEntities => super._childEntities
|
| - ..add(externalKeyword)
|
| - ..add(constKeyword)
|
| - ..add(factoryKeyword)
|
| - ..add(_returnType)
|
| - ..add(period)
|
| - ..add(_name)
|
| - ..add(_parameters)
|
| - ..add(separator)
|
| - ..addAll(initializers)
|
| - ..add(_redirectedConstructor)
|
| - ..add(_body);
|
| -
|
| - @override
|
| - Token get endToken {
|
| - if (_body != null) {
|
| - return _body.endToken;
|
| - } else if (!_initializers.isEmpty) {
|
| - return _initializers.endToken;
|
| - }
|
| - return _parameters.endToken;
|
| - }
|
| -
|
| - @override
|
| - Token get firstTokenAfterCommentAndMetadata {
|
| - Token leftMost =
|
| - Token.lexicallyFirst([externalKeyword, constKeyword, factoryKeyword]);
|
| - if (leftMost != null) {
|
| - return leftMost;
|
| - }
|
| - return _returnType.beginToken;
|
| - }
|
| -
|
| - /**
|
| - * Return the initializers associated with the constructor.
|
| - */
|
| - NodeList<ConstructorInitializer> get initializers => _initializers;
|
| -
|
| - /**
|
| - * Return the name of the constructor, or `null` if the constructor being
|
| - * declared is unnamed.
|
| - */
|
| - SimpleIdentifier get name => _name;
|
| -
|
| - /**
|
| - * Set the name of the constructor to the given [identifier].
|
| - */
|
| - void set name(SimpleIdentifier identifier) {
|
| - _name = _becomeParentOf(identifier);
|
| - }
|
| -
|
| - /**
|
| - * Return the parameters associated with the constructor.
|
| - */
|
| - FormalParameterList get parameters => _parameters;
|
| -
|
| - /**
|
| - * Set the parameters associated with the constructor to the given list of
|
| - * [parameters].
|
| - */
|
| - void set parameters(FormalParameterList parameters) {
|
| - _parameters = _becomeParentOf(parameters);
|
| - }
|
| -
|
| - /**
|
| - * Return the name of the constructor to which this constructor will be
|
| - * redirected, or `null` if this is not a redirecting factory constructor.
|
| - */
|
| - ConstructorName get redirectedConstructor => _redirectedConstructor;
|
| -
|
| - /**
|
| - * Set the name of the constructor to which this constructor will be
|
| - * redirected to the given [redirectedConstructor] name.
|
| - */
|
| - void set redirectedConstructor(ConstructorName redirectedConstructor) {
|
| - _redirectedConstructor = _becomeParentOf(redirectedConstructor);
|
| - }
|
| -
|
| - /**
|
| - * Return the type of object being created. This can be different than the
|
| - * type in which the constructor is being declared if the constructor is the
|
| - * implementation of a factory constructor.
|
| - */
|
| - Identifier get returnType => _returnType;
|
| -
|
| - /**
|
| - * Set the type of object being created to the given [typeName].
|
| - */
|
| - void set returnType(Identifier typeName) {
|
| - _returnType = _becomeParentOf(typeName);
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitConstructorDeclaration(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - super.visitChildren(visitor);
|
| - _safelyVisitChild(_returnType, visitor);
|
| - _safelyVisitChild(_name, visitor);
|
| - _safelyVisitChild(_parameters, visitor);
|
| - _initializers.accept(visitor);
|
| - _safelyVisitChild(_redirectedConstructor, visitor);
|
| - _safelyVisitChild(_body, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * The initialization of a field within a constructor's initialization list.
|
| - *
|
| - * > fieldInitializer ::=
|
| - * > ('this' '.')? [SimpleIdentifier] '=' [Expression]
|
| - */
|
| -class ConstructorFieldInitializer extends ConstructorInitializer {
|
| - /**
|
| - * The token for the 'this' keyword, or `null` if there is no 'this' keyword.
|
| - */
|
| - Token thisKeyword;
|
| -
|
| - /**
|
| - * The token for the period after the 'this' keyword, or `null` if there is no
|
| - * 'this' keyword.
|
| - */
|
| - Token period;
|
| -
|
| - /**
|
| - * The name of the field being initialized.
|
| - */
|
| - SimpleIdentifier _fieldName;
|
| -
|
| - /**
|
| - * The token for the equal sign between the field name and the expression.
|
| - */
|
| - Token equals;
|
| -
|
| - /**
|
| - * The expression computing the value to which the field will be initialized.
|
| - */
|
| - Expression _expression;
|
| -
|
| - /**
|
| - * Initialize a newly created field initializer to initialize the field with
|
| - * the given name to the value of the given expression. The [thisKeyword] and
|
| - * [period] can be `null` if the 'this' keyword was not specified.
|
| - */
|
| - ConstructorFieldInitializer(this.thisKeyword, this.period,
|
| - SimpleIdentifier fieldName, this.equals, Expression expression) {
|
| - _fieldName = _becomeParentOf(fieldName);
|
| - _expression = _becomeParentOf(expression);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken {
|
| - if (thisKeyword != null) {
|
| - return thisKeyword;
|
| - }
|
| - return _fieldName.beginToken;
|
| - }
|
| -
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()
|
| - ..add(thisKeyword)
|
| - ..add(period)
|
| - ..add(_fieldName)
|
| - ..add(equals)
|
| - ..add(_expression);
|
| -
|
| - @override
|
| - Token get endToken => _expression.endToken;
|
| -
|
| - /**
|
| - * Return the expression computing the value to which the field will be
|
| - * initialized.
|
| - */
|
| - Expression get expression => _expression;
|
| -
|
| - /**
|
| - * Set the expression computing the value to which the field will be
|
| - * initialized to the given [expression].
|
| - */
|
| - void set expression(Expression expression) {
|
| - _expression = _becomeParentOf(expression);
|
| - }
|
| -
|
| - /**
|
| - * Return the name of the field being initialized.
|
| - */
|
| - SimpleIdentifier get fieldName => _fieldName;
|
| -
|
| - /**
|
| - * Set the name of the field being initialized to the given [identifier].
|
| - */
|
| - void set fieldName(SimpleIdentifier identifier) {
|
| - _fieldName = _becomeParentOf(identifier);
|
| - }
|
| -
|
| - /**
|
| - * Return the token for the 'this' keyword, or `null` if there is no 'this'
|
| - * keyword.
|
| - */
|
| - @deprecated // Use "this.thisKeyword"
|
| - Token get keyword => thisKeyword;
|
| -
|
| - /**
|
| - * Set the token for the 'this' keyword to the given [token].
|
| - */
|
| - @deprecated // Use "this.thisKeyword"
|
| - set keyword(Token token) {
|
| - thisKeyword = token;
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitConstructorFieldInitializer(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_fieldName, visitor);
|
| - _safelyVisitChild(_expression, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A node that can occur in the initializer list of a constructor declaration.
|
| - *
|
| - * > constructorInitializer ::=
|
| - * > [SuperConstructorInvocation]
|
| - * > | [ConstructorFieldInitializer]
|
| - */
|
| -abstract class ConstructorInitializer extends AstNode {}
|
| -
|
| -/**
|
| - * The name of the constructor.
|
| - *
|
| - * > constructorName ::=
|
| - * > type ('.' identifier)?
|
| - */
|
| -class ConstructorName extends AstNode {
|
| - /**
|
| - * The name of the type defining the constructor.
|
| - */
|
| - TypeName _type;
|
| -
|
| - /**
|
| - * The token for the period before the constructor name, or `null` if the
|
| - * specified constructor is the unnamed constructor.
|
| - */
|
| - Token period;
|
| -
|
| - /**
|
| - * The name of the constructor, or `null` if the specified constructor is the
|
| - * unnamed constructor.
|
| - */
|
| - SimpleIdentifier _name;
|
| -
|
| - /**
|
| - * The element associated with this constructor name based on static type
|
| - * information, or `null` if the AST structure has not been resolved or if
|
| - * this constructor name could not be resolved.
|
| - */
|
| - ConstructorElement staticElement;
|
| -
|
| - /**
|
| - * Initialize a newly created constructor name. The [period] and [name] can be
|
| - * `null` if the constructor being named is the unnamed constructor.
|
| - */
|
| - ConstructorName(TypeName type, this.period, SimpleIdentifier name) {
|
| - _type = _becomeParentOf(type);
|
| - _name = _becomeParentOf(name);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => _type.beginToken;
|
| -
|
| - @override
|
| - Iterable get childEntities =>
|
| - new ChildEntities()..add(_type)..add(period)..add(_name);
|
| -
|
| - @override
|
| - Token get endToken {
|
| - if (_name != null) {
|
| - return _name.endToken;
|
| - }
|
| - return _type.endToken;
|
| - }
|
| -
|
| - /**
|
| - * Return the name of the constructor, or `null` if the specified constructor
|
| - * is the unnamed constructor.
|
| - */
|
| - SimpleIdentifier get name => _name;
|
| -
|
| - /**
|
| - * Set the name of the constructor to the given [name].
|
| - */
|
| - void set name(SimpleIdentifier name) {
|
| - _name = _becomeParentOf(name);
|
| - }
|
| -
|
| - /**
|
| - * Return the name of the type defining the constructor.
|
| - */
|
| - TypeName get type => _type;
|
| -
|
| - /**
|
| - * Set the name of the type defining the constructor to the given [type] name.
|
| - */
|
| - void set type(TypeName type) {
|
| - _type = _becomeParentOf(type);
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitConstructorName(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_type, visitor);
|
| - _safelyVisitChild(_name, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A continue statement.
|
| - *
|
| - * > continueStatement ::=
|
| - * > 'continue' [SimpleIdentifier]? ';'
|
| - */
|
| -class ContinueStatement extends Statement {
|
| - /**
|
| - * The token representing the 'continue' keyword.
|
| - */
|
| - Token continueKeyword;
|
| -
|
| - /**
|
| - * The label associated with the statement, or `null` if there is no label.
|
| - */
|
| - SimpleIdentifier _label;
|
| -
|
| - /**
|
| - * The semicolon terminating the statement.
|
| - */
|
| - Token semicolon;
|
| -
|
| - /**
|
| - * The AstNode which this continue statement is continuing to. This will be
|
| - * either a Statement (in the case of continuing a loop) or a SwitchMember
|
| - * (in the case of continuing from one switch case to another). Null if the
|
| - * AST has not yet been resolved or if the target could not be resolved.
|
| - * Note that if the source code has errors, the target may be invalid (e.g.
|
| - * the target may be in an enclosing function).
|
| - */
|
| - AstNode target;
|
| -
|
| - /**
|
| - * Initialize a newly created continue statement. The [label] can be `null` if
|
| - * there is no label associated with the statement.
|
| - */
|
| - ContinueStatement(
|
| - this.continueKeyword, SimpleIdentifier label, this.semicolon) {
|
| - _label = _becomeParentOf(label);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => continueKeyword;
|
| -
|
| - @override
|
| - Iterable get childEntities =>
|
| - new ChildEntities()..add(continueKeyword)..add(_label)..add(semicolon);
|
| -
|
| - @override
|
| - Token get endToken => semicolon;
|
| -
|
| - /**
|
| - * Return the token for the 'continue' keyword, or `null` if there is no
|
| - * 'continue' keyword.
|
| - */
|
| - @deprecated // Use "this.continueKeyword"
|
| - Token get keyword => continueKeyword;
|
| -
|
| - /**
|
| - * Set the token for the 'continue' keyword to the given [token].
|
| - */
|
| - @deprecated // Use "this.continueKeyword"
|
| - set keyword(Token token) {
|
| - continueKeyword = token;
|
| - }
|
| -
|
| - /**
|
| - * Return the label associated with the statement, or `null` if there is no
|
| - * label.
|
| - */
|
| - SimpleIdentifier get label => _label;
|
| -
|
| - /**
|
| - * Set the label associated with the statement to the given [identifier].
|
| - */
|
| - void set label(SimpleIdentifier identifier) {
|
| - _label = _becomeParentOf(identifier);
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitContinueStatement(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_label, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * 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);
|
| -
|
| - /**
|
| - * Return the element associated with this declaration, or `null` if either
|
| - * this node corresponds to a list of declarations or if the AST structure has
|
| - * not been resolved.
|
| - */
|
| - Element get element;
|
| -}
|
| -
|
| -/**
|
| - * The declaration of a single identifier.
|
| - *
|
| - * > declaredIdentifier ::=
|
| - * > [Annotation] finalConstVarOrType [SimpleIdentifier]
|
| - */
|
| -class DeclaredIdentifier extends Declaration {
|
| - /**
|
| - * The token representing either the 'final', 'const' or 'var' keyword, or
|
| - * `null` if no keyword was used.
|
| - */
|
| - Token keyword;
|
| -
|
| - /**
|
| - * The name of the declared type of the parameter, or `null` if the parameter
|
| - * does not have a declared type.
|
| - */
|
| - TypeName _type;
|
| -
|
| - /**
|
| - * The name of the variable being declared.
|
| - */
|
| - SimpleIdentifier _identifier;
|
| -
|
| - /**
|
| - * Initialize a newly created formal parameter. Either or both of the
|
| - * [comment] and [metadata] can be `null` if the declaration does not have the
|
| - * corresponding attribute. The [keyword] can be `null` if a type name is
|
| - * given. The [type] must be `null` if the keyword is 'var'.
|
| - */
|
| - DeclaredIdentifier(Comment comment, List<Annotation> metadata, this.keyword,
|
| - TypeName type, SimpleIdentifier identifier)
|
| - : super(comment, metadata) {
|
| - _type = _becomeParentOf(type);
|
| - _identifier = _becomeParentOf(identifier);
|
| - }
|
| -
|
| - @override
|
| - Iterable get childEntities =>
|
| - super._childEntities..add(keyword)..add(_type)..add(_identifier);
|
| -
|
| - @override
|
| - LocalVariableElement get element {
|
| - if (_identifier == null) {
|
| - return null;
|
| - }
|
| - return _identifier.staticElement as LocalVariableElement;
|
| - }
|
| -
|
| - @override
|
| - Token get endToken => _identifier.endToken;
|
| -
|
| - @override
|
| - Token get firstTokenAfterCommentAndMetadata {
|
| - if (keyword != null) {
|
| - return keyword;
|
| - } else if (_type != null) {
|
| - return _type.beginToken;
|
| - }
|
| - return _identifier.beginToken;
|
| - }
|
| -
|
| - /**
|
| - * Return the name of the variable being declared.
|
| - */
|
| - SimpleIdentifier get identifier => _identifier;
|
| -
|
| - /**
|
| - * Set the name of the variable being declared to the given [identifier].
|
| - */
|
| - void set identifier(SimpleIdentifier identifier) {
|
| - _identifier = _becomeParentOf(identifier);
|
| - }
|
| -
|
| - /**
|
| - * Return `true` if this variable was declared with the 'const' modifier.
|
| - */
|
| - bool get isConst => (keyword is KeywordToken) &&
|
| - (keyword as KeywordToken).keyword == Keyword.CONST;
|
| -
|
| - /**
|
| - * Return `true` if this variable was declared with the 'final' modifier.
|
| - * Variables that are declared with the 'const' modifier will return `false`
|
| - * even though they are implicitly final.
|
| - */
|
| - bool get isFinal => (keyword is KeywordToken) &&
|
| - (keyword as KeywordToken).keyword == Keyword.FINAL;
|
| -
|
| - /**
|
| - * Return the name of the declared type of the parameter, or `null` if the
|
| - * parameter does not have a declared type.
|
| - */
|
| - TypeName get type => _type;
|
| -
|
| - /**
|
| - * Set the name of the declared type of the parameter to the given [typeName].
|
| - */
|
| - void set type(TypeName typeName) {
|
| - _type = _becomeParentOf(typeName);
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitDeclaredIdentifier(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - super.visitChildren(visitor);
|
| - _safelyVisitChild(_type, visitor);
|
| - _safelyVisitChild(_identifier, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A formal parameter with a default value. There are two kinds of parameters
|
| - * that are both represented by this class: named formal parameters and
|
| - * positional formal parameters.
|
| - *
|
| - * > defaultFormalParameter ::=
|
| - * > [NormalFormalParameter] ('=' [Expression])?
|
| - * >
|
| - * > defaultNamedParameter ::=
|
| - * > [NormalFormalParameter] (':' [Expression])?
|
| - */
|
| -class DefaultFormalParameter extends FormalParameter {
|
| - /**
|
| - * The formal parameter with which the default value is associated.
|
| - */
|
| - NormalFormalParameter _parameter;
|
| -
|
| - /**
|
| - * The kind of this parameter.
|
| - */
|
| - ParameterKind kind;
|
| -
|
| - /**
|
| - * The token separating the parameter from the default value, or `null` if
|
| - * there is no default value.
|
| - */
|
| - Token separator;
|
| -
|
| - /**
|
| - * The expression computing the default value for the parameter, or `null` if
|
| - * there is no default value.
|
| - */
|
| - Expression _defaultValue;
|
| -
|
| - /**
|
| - * Initialize a newly created default formal parameter. The [separator] and
|
| - * [defaultValue] can be `null` if there is no default value.
|
| - */
|
| - DefaultFormalParameter(NormalFormalParameter parameter, this.kind,
|
| - this.separator, Expression defaultValue) {
|
| - _parameter = _becomeParentOf(parameter);
|
| - _defaultValue = _becomeParentOf(defaultValue);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => _parameter.beginToken;
|
| -
|
| - @override
|
| - Iterable get childEntities =>
|
| - new ChildEntities()..add(_parameter)..add(separator)..add(_defaultValue);
|
| -
|
| - /**
|
| - * Return the expression computing the default value for the parameter, or
|
| - * `null` if there is no default value.
|
| - */
|
| - Expression get defaultValue => _defaultValue;
|
| -
|
| - /**
|
| - * Set the expression computing the default value for the parameter to the
|
| - * given [expression].
|
| - */
|
| - void set defaultValue(Expression expression) {
|
| - _defaultValue = _becomeParentOf(expression);
|
| - }
|
| -
|
| - @override
|
| - Token get endToken {
|
| - if (_defaultValue != null) {
|
| - return _defaultValue.endToken;
|
| - }
|
| - return _parameter.endToken;
|
| - }
|
| -
|
| - @override
|
| - SimpleIdentifier get identifier => _parameter.identifier;
|
| -
|
| - @override
|
| - bool get isConst => _parameter != null && _parameter.isConst;
|
| -
|
| - @override
|
| - bool get isFinal => _parameter != null && _parameter.isFinal;
|
| -
|
| - /**
|
| - * Return the formal parameter with which the default value is associated.
|
| - */
|
| - NormalFormalParameter get parameter => _parameter;
|
| -
|
| - /**
|
| - * Set the formal parameter with which the default value is associated to the
|
| - * given [formalParameter].
|
| - */
|
| - void set parameter(NormalFormalParameter formalParameter) {
|
| - _parameter = _becomeParentOf(formalParameter);
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitDefaultFormalParameter(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_parameter, visitor);
|
| - _safelyVisitChild(_defaultValue, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A recursive AST visitor that is used to run over [Expression]s to determine
|
| - * whether the expression is composed by at least one deferred
|
| - * [PrefixedIdentifier].
|
| - *
|
| - * See [PrefixedIdentifier.isDeferred].
|
| - */
|
| -class DeferredLibraryReferenceDetector extends RecursiveAstVisitor<Object> {
|
| - /**
|
| - * A flag indicating whether an identifier from a deferred library has been
|
| - * found.
|
| - */
|
| - bool _result = false;
|
| -
|
| - /**
|
| - * Return `true` if the visitor found a [PrefixedIdentifier] that returned
|
| - * `true` to the [PrefixedIdentifier.isDeferred] query.
|
| - */
|
| - bool get result => _result;
|
| -
|
| - @override
|
| - Object visitPrefixedIdentifier(PrefixedIdentifier node) {
|
| - if (!_result) {
|
| - if (node.isDeferred) {
|
| - _result = true;
|
| - }
|
| - }
|
| - return null;
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A node that represents a directive.
|
| - *
|
| - * > directive ::=
|
| - * > [ExportDirective]
|
| - * > | [ImportDirective]
|
| - * > | [LibraryDirective]
|
| - * > | [PartDirective]
|
| - * > | [PartOfDirective]
|
| - */
|
| -abstract class Directive extends AnnotatedNode {
|
| - /**
|
| - * The element associated with this directive, or `null` if the AST structure
|
| - * has not been resolved or if this directive could not be resolved.
|
| - */
|
| - Element element;
|
| -
|
| - /**
|
| - * Initialize a newly create directive. Either or both of the [comment] and
|
| - * [metadata] can be `null` if the directive does not have the corresponding
|
| - * attribute.
|
| - */
|
| - Directive(Comment comment, List<Annotation> metadata)
|
| - : super(comment, metadata);
|
| -
|
| - /**
|
| - * Return the token representing the keyword that introduces this directive
|
| - * ('import', 'export', 'library' or 'part').
|
| - */
|
| - Token get keyword;
|
| -}
|
| -
|
| -/**
|
| - * A do statement.
|
| - *
|
| - * > doStatement ::=
|
| - * > 'do' [Statement] 'while' '(' [Expression] ')' ';'
|
| - */
|
| -class DoStatement extends Statement {
|
| - /**
|
| - * The token representing the 'do' keyword.
|
| - */
|
| - Token doKeyword;
|
| -
|
| - /**
|
| - * The body of the loop.
|
| - */
|
| - Statement _body;
|
| -
|
| - /**
|
| - * The token representing the 'while' keyword.
|
| - */
|
| - Token whileKeyword;
|
| -
|
| - /**
|
| - * The left parenthesis.
|
| - */
|
| - Token leftParenthesis;
|
| -
|
| - /**
|
| - * The condition that determines when the loop will terminate.
|
| - */
|
| - Expression _condition;
|
| -
|
| - /**
|
| - * The right parenthesis.
|
| - */
|
| - Token rightParenthesis;
|
| -
|
| - /**
|
| - * The semicolon terminating the statement.
|
| - */
|
| - Token semicolon;
|
| -
|
| - /**
|
| - * Initialize a newly created do loop.
|
| - */
|
| - DoStatement(this.doKeyword, Statement body, this.whileKeyword,
|
| - this.leftParenthesis, Expression condition, this.rightParenthesis,
|
| - this.semicolon) {
|
| - _body = _becomeParentOf(body);
|
| - _condition = _becomeParentOf(condition);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => doKeyword;
|
| -
|
| - /**
|
| - * Return the body of the loop.
|
| - */
|
| - Statement get body => _body;
|
| -
|
| - /**
|
| - * Set the body of the loop to the given [statement].
|
| - */
|
| - void set body(Statement statement) {
|
| - _body = _becomeParentOf(statement);
|
| - }
|
| -
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()
|
| - ..add(doKeyword)
|
| - ..add(_body)
|
| - ..add(whileKeyword)
|
| - ..add(leftParenthesis)
|
| - ..add(_condition)
|
| - ..add(rightParenthesis)
|
| - ..add(semicolon);
|
| -
|
| - /**
|
| - * Return the condition that determines when the loop will terminate.
|
| - */
|
| - Expression get condition => _condition;
|
| -
|
| - /**
|
| - * Set the condition that determines when the loop will terminate to the given
|
| - * [expression].
|
| - */
|
| - void set condition(Expression expression) {
|
| - _condition = _becomeParentOf(expression);
|
| - }
|
| -
|
| - @override
|
| - Token get endToken => semicolon;
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitDoStatement(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_body, visitor);
|
| - _safelyVisitChild(_condition, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A floating point literal expression.
|
| - *
|
| - * > doubleLiteral ::=
|
| - * > decimalDigit+ ('.' decimalDigit*)? exponent?
|
| - * > | '.' decimalDigit+ exponent?
|
| - * >
|
| - * > exponent ::=
|
| - * > ('e' | 'E') ('+' | '-')? decimalDigit+
|
| - */
|
| -class DoubleLiteral extends Literal {
|
| - /**
|
| - * The token representing the literal.
|
| - */
|
| - Token literal;
|
| -
|
| - /**
|
| - * The value of the literal.
|
| - */
|
| - double value;
|
| -
|
| - /**
|
| - * Initialize a newly created floating point literal.
|
| - */
|
| - DoubleLiteral(this.literal, this.value);
|
| -
|
| - @override
|
| - Token get beginToken => literal;
|
| -
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()..add(literal);
|
| -
|
| - @override
|
| - Token get endToken => literal;
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitDoubleLiteral(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - // There are no children to visit.
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * An object used to locate the [Element] associated with a given [AstNode].
|
| - */
|
| -class ElementLocator {
|
| - /**
|
| - * Return the element associated with the given [node], or `null` if there is
|
| - * no element associated with the node.
|
| - */
|
| - static Element locate(AstNode node) {
|
| - if (node == null) {
|
| - return null;
|
| - }
|
| - ElementLocator_ElementMapper mapper = new ElementLocator_ElementMapper();
|
| - return node.accept(mapper);
|
| - }
|
| -
|
| - /**
|
| - * Return the element associated with the given [node], or `null` if there is
|
| - * no element associated with the node.
|
| - */
|
| - static Element locateWithOffset(AstNode node, int offset) {
|
| - // TODO(brianwilkerson) 'offset' is not used. Figure out what's going on:
|
| - // whether there's a bug or whether this method is unnecessary.
|
| - if (node == null) {
|
| - return null;
|
| - }
|
| - // try to get Element from node
|
| - Element nodeElement = locate(node);
|
| - if (nodeElement != null) {
|
| - return nodeElement;
|
| - }
|
| - // no Element
|
| - return null;
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * Visitor that maps nodes to elements.
|
| - */
|
| -class ElementLocator_ElementMapper extends GeneralizingAstVisitor<Element> {
|
| - @override
|
| - Element visitAnnotation(Annotation node) => node.element;
|
| -
|
| - @override
|
| - Element visitAssignmentExpression(AssignmentExpression node) =>
|
| - node.bestElement;
|
| -
|
| - @override
|
| - Element visitBinaryExpression(BinaryExpression node) => node.bestElement;
|
| -
|
| - @override
|
| - Element visitClassDeclaration(ClassDeclaration node) => node.element;
|
| -
|
| - @override
|
| - Element visitCompilationUnit(CompilationUnit node) => node.element;
|
| -
|
| - @override
|
| - Element visitConstructorDeclaration(ConstructorDeclaration node) =>
|
| - node.element;
|
| -
|
| - @override
|
| - Element visitFunctionDeclaration(FunctionDeclaration node) => node.element;
|
| -
|
| - @override
|
| - Element visitIdentifier(Identifier node) {
|
| - AstNode parent = node.parent;
|
| - // Type name in Annotation
|
| - if (parent is Annotation) {
|
| - Annotation annotation = parent;
|
| - if (identical(annotation.name, node) &&
|
| - annotation.constructorName == null) {
|
| - return annotation.element;
|
| - }
|
| - }
|
| - // Extra work to map Constructor Declarations to their associated
|
| - // Constructor Elements
|
| - if (parent is ConstructorDeclaration) {
|
| - ConstructorDeclaration decl = parent;
|
| - Identifier returnType = decl.returnType;
|
| - if (identical(returnType, node)) {
|
| - SimpleIdentifier name = decl.name;
|
| - if (name != null) {
|
| - return name.bestElement;
|
| - }
|
| - Element element = node.bestElement;
|
| - if (element is ClassElement) {
|
| - return element.unnamedConstructor;
|
| - }
|
| - }
|
| - }
|
| - if (parent is LibraryIdentifier) {
|
| - AstNode grandParent = parent.parent;
|
| - if (grandParent is PartOfDirective) {
|
| - Element element = grandParent.element;
|
| - if (element is LibraryElement) {
|
| - return element.definingCompilationUnit;
|
| - }
|
| - }
|
| - }
|
| - return node.bestElement;
|
| - }
|
| -
|
| - @override
|
| - Element visitImportDirective(ImportDirective node) => node.element;
|
| -
|
| - @override
|
| - Element visitIndexExpression(IndexExpression node) => node.bestElement;
|
| -
|
| - @override
|
| - Element visitInstanceCreationExpression(InstanceCreationExpression node) =>
|
| - node.staticElement;
|
| -
|
| - @override
|
| - Element visitLibraryDirective(LibraryDirective node) => node.element;
|
| -
|
| - @override
|
| - Element visitMethodDeclaration(MethodDeclaration node) => node.element;
|
| -
|
| - @override
|
| - Element visitMethodInvocation(MethodInvocation node) =>
|
| - node.methodName.bestElement;
|
| -
|
| - @override
|
| - Element visitPostfixExpression(PostfixExpression node) => node.bestElement;
|
| -
|
| - @override
|
| - Element visitPrefixedIdentifier(PrefixedIdentifier node) => node.bestElement;
|
| -
|
| - @override
|
| - Element visitPrefixExpression(PrefixExpression node) => node.bestElement;
|
| -
|
| - @override
|
| - Element visitStringLiteral(StringLiteral node) {
|
| - AstNode parent = node.parent;
|
| - if (parent is UriBasedDirective) {
|
| - return parent.uriElement;
|
| - }
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Element visitVariableDeclaration(VariableDeclaration node) => node.element;
|
| -}
|
| -
|
| -/**
|
| - * An empty function body, which can only appear in constructors or abstract
|
| - * methods.
|
| - *
|
| - * > emptyFunctionBody ::=
|
| - * > ';'
|
| - */
|
| -class EmptyFunctionBody extends FunctionBody {
|
| - /**
|
| - * The token representing the semicolon that marks the end of the function
|
| - * body.
|
| - */
|
| - Token semicolon;
|
| -
|
| - /**
|
| - * Initialize a newly created function body.
|
| - */
|
| - EmptyFunctionBody(this.semicolon);
|
| -
|
| - @override
|
| - Token get beginToken => semicolon;
|
| -
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()..add(semicolon);
|
| -
|
| - @override
|
| - Token get endToken => semicolon;
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitEmptyFunctionBody(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - // Empty function bodies have no children.
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * An empty statement.
|
| - *
|
| - * > emptyStatement ::=
|
| - * > ';'
|
| - */
|
| -class EmptyStatement extends Statement {
|
| - /**
|
| - * The semicolon terminating the statement.
|
| - */
|
| - Token semicolon;
|
| -
|
| - /**
|
| - * Initialize a newly created empty statement.
|
| - */
|
| - EmptyStatement(this.semicolon);
|
| -
|
| - @override
|
| - Token get beginToken => semicolon;
|
| -
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()..add(semicolon);
|
| -
|
| - @override
|
| - Token get endToken => semicolon;
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitEmptyStatement(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - // There are no children to visit.
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * The declaration of an enum constant.
|
| - */
|
| -class EnumConstantDeclaration extends Declaration {
|
| - /**
|
| - * The name of the constant.
|
| - */
|
| - SimpleIdentifier _name;
|
| -
|
| - /**
|
| - * Initialize a newly created enum constant declaration. Either or both of the
|
| - * [comment] and [metadata] can be `null` if the constant does not have the
|
| - * corresponding attribute. (Technically, enum constants cannot have metadata,
|
| - * but we allow it for consistency.)
|
| - */
|
| - EnumConstantDeclaration(
|
| - Comment comment, List<Annotation> metadata, SimpleIdentifier name)
|
| - : super(comment, metadata) {
|
| - _name = _becomeParentOf(name);
|
| - }
|
| -
|
| - @override
|
| - Iterable get childEntities => super._childEntities..add(_name);
|
| -
|
| - @override
|
| - FieldElement get element =>
|
| - _name == null ? null : (_name.staticElement as FieldElement);
|
| -
|
| - @override
|
| - Token get endToken => _name.endToken;
|
| -
|
| - @override
|
| - Token get firstTokenAfterCommentAndMetadata => _name.beginToken;
|
| -
|
| - /**
|
| - * Return the name of the constant.
|
| - */
|
| - SimpleIdentifier get name => _name;
|
| -
|
| - /**
|
| - * Set the name of the constant to the given [name].
|
| - */
|
| - void set name(SimpleIdentifier name) {
|
| - _name = _becomeParentOf(name);
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitEnumConstantDeclaration(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - super.visitChildren(visitor);
|
| - _safelyVisitChild(_name, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * The declaration of an enumeration.
|
| - *
|
| - * > enumType ::=
|
| - * > metadata 'enum' [SimpleIdentifier] '{' [SimpleIdentifier] (',' [SimpleIdentifier])* (',')? '}'
|
| - */
|
| -class EnumDeclaration extends NamedCompilationUnitMember {
|
| - /**
|
| - * The 'enum' keyword.
|
| - */
|
| - Token enumKeyword;
|
| -
|
| - /**
|
| - * 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) {
|
| - _constants = new NodeList<EnumConstantDeclaration>(this, constants);
|
| - }
|
| -
|
| - @override
|
| - // TODO(brianwilkerson) Add commas?
|
| - Iterable get childEntities => super._childEntities
|
| - ..add(enumKeyword)
|
| - ..add(_name)
|
| - ..add(leftBracket)
|
| - ..addAll(_constants)
|
| - ..add(rightBracket);
|
| -
|
| - /**
|
| - * Return the enumeration constants being declared.
|
| - */
|
| - NodeList<EnumConstantDeclaration> get constants => _constants;
|
| -
|
| - @override
|
| - ClassElement get element =>
|
| - _name != null ? (_name.staticElement as ClassElement) : null;
|
| -
|
| - @override
|
| - Token get endToken => rightBracket;
|
| -
|
| - @override
|
| - Token get firstTokenAfterCommentAndMetadata => enumKeyword;
|
| -
|
| - /**
|
| - * Return the token for the 'enum' keyword, or `null` if there is no
|
| - * 'enum' keyword.
|
| - */
|
| - @deprecated // Use "this.enumKeyword"
|
| - 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;
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitEnumDeclaration(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - super.visitChildren(visitor);
|
| - _safelyVisitChild(_name, visitor);
|
| - _constants.accept(visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * Ephemeral identifiers are created as needed to mimic the presence of an empty
|
| - * identifier.
|
| - */
|
| -class EphemeralIdentifier extends SimpleIdentifier {
|
| - EphemeralIdentifier(AstNode parent, int location)
|
| - : super(new StringToken(TokenType.IDENTIFIER, "", location)) {
|
| - parent._becomeParentOf(this);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * An export directive.
|
| - *
|
| - * > exportDirective ::=
|
| - * > [Annotation] 'export' [StringLiteral] [Combinator]* ';'
|
| - */
|
| -class ExportDirective extends NamespaceDirective {
|
| - /**
|
| - * Initialize a newly created export directive. Either or both of the
|
| - * [comment] and [metadata] can be `null` if the directive does not have the
|
| - * corresponding attribute. The list of [combinators] can be `null` if there
|
| - * are no combinators.
|
| - */
|
| - ExportDirective(Comment comment, List<Annotation> metadata, Token keyword,
|
| - StringLiteral libraryUri, List<Combinator> combinators, Token semicolon)
|
| - : super(comment, metadata, keyword, libraryUri, combinators, semicolon);
|
| -
|
| - @override
|
| - Iterable get childEntities => super._childEntities
|
| - ..add(_uri)
|
| - ..addAll(combinators)
|
| - ..add(semicolon);
|
| -
|
| - @override
|
| - ExportElement get element => super.element as ExportElement;
|
| -
|
| - @override
|
| - LibraryElement get uriElement {
|
| - if (element != null) {
|
| - return element.exportedLibrary;
|
| - }
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitExportDirective(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - super.visitChildren(visitor);
|
| - combinators.accept(visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A node that represents an expression.
|
| - *
|
| - * > expression ::=
|
| - * > [AssignmentExpression]
|
| - * > | [ConditionalExpression] cascadeSection*
|
| - * > | [ThrowExpression]
|
| - */
|
| -abstract class Expression extends AstNode {
|
| - /**
|
| - * An empty list of expressions.
|
| - */
|
| - @deprecated // Use "Expression.EMPTY_LIST"
|
| - static const List<Expression> EMPTY_ARRAY = EMPTY_LIST;
|
| -
|
| - /**
|
| - * An empty list of expressions.
|
| - */
|
| - static const List<Expression> EMPTY_LIST = const <Expression>[];
|
| -
|
| - /**
|
| - * The static type of this expression, or `null` if the AST structure has not
|
| - * been resolved.
|
| - */
|
| - DartType staticType;
|
| -
|
| - /**
|
| - * The propagated type of this expression, or `null` if type propagation has
|
| - * not been performed on the AST structure.
|
| - */
|
| - DartType propagatedType;
|
| -
|
| - /**
|
| - * Return the best parameter element information available for this
|
| - * expression. If type propagation was able to find a better parameter element
|
| - * than static analysis, that type will be returned. Otherwise, the result of
|
| - * static analysis will be returned.
|
| - */
|
| - ParameterElement get bestParameterElement {
|
| - ParameterElement propagatedElement = propagatedParameterElement;
|
| - if (propagatedElement != null) {
|
| - return propagatedElement;
|
| - }
|
| - return staticParameterElement;
|
| - }
|
| -
|
| - /**
|
| - * Return the best type information available for this expression. If type
|
| - * propagation was able to find a better type than static analysis, that type
|
| - * will be returned. Otherwise, the result of static analysis will be
|
| - * returned. If no type analysis has been performed, then the type 'dynamic'
|
| - * will be returned.
|
| - */
|
| - DartType get bestType {
|
| - if (propagatedType != null) {
|
| - return propagatedType;
|
| - } else if (staticType != null) {
|
| - return staticType;
|
| - }
|
| - return DynamicTypeImpl.instance;
|
| - }
|
| -
|
| - /**
|
| - * Return `true` if this expression is syntactically valid for the LHS of an
|
| - * [AssignmentExpression].
|
| - */
|
| - bool get isAssignable => false;
|
| -
|
| - /**
|
| - * Return the precedence of this expression. The precedence is a positive
|
| - * integer value that defines how the source code is parsed into an AST. For
|
| - * example `a * b + c` is parsed as `(a * b) + c` because the precedence of
|
| - * `*` is greater than the precedence of `+`.
|
| - *
|
| - * Clients should not assume that returned values will stay the same, they
|
| - * might change as result of specification change. Only relative order should
|
| - * be used.
|
| - */
|
| - int get precedence;
|
| -
|
| - /**
|
| - * If this expression is an argument to an invocation, and the AST structure
|
| - * has been resolved, and the function being invoked is known based on
|
| - * propagated type information, and this expression corresponds to one of the
|
| - * parameters of the function being invoked, then return the parameter element
|
| - * representing the parameter to which the value of this expression will be
|
| - * bound. Otherwise, return `null`.
|
| - */
|
| - ParameterElement get propagatedParameterElement {
|
| - AstNode parent = this.parent;
|
| - if (parent is ArgumentList) {
|
| - return parent._getPropagatedParameterElementFor(this);
|
| - } else if (parent is IndexExpression) {
|
| - IndexExpression indexExpression = parent;
|
| - if (identical(indexExpression.index, this)) {
|
| - return indexExpression._propagatedParameterElementForIndex;
|
| - }
|
| - } else if (parent is BinaryExpression) {
|
| - BinaryExpression binaryExpression = parent;
|
| - if (identical(binaryExpression.rightOperand, this)) {
|
| - return binaryExpression._propagatedParameterElementForRightOperand;
|
| - }
|
| - } else if (parent is AssignmentExpression) {
|
| - AssignmentExpression assignmentExpression = parent;
|
| - if (identical(assignmentExpression.rightHandSide, this)) {
|
| - return assignmentExpression._propagatedParameterElementForRightHandSide;
|
| - }
|
| - } else if (parent is PrefixExpression) {
|
| - return parent._propagatedParameterElementForOperand;
|
| - } else if (parent is PostfixExpression) {
|
| - return parent._propagatedParameterElementForOperand;
|
| - }
|
| - return null;
|
| - }
|
| -
|
| - /**
|
| - * If this expression is an argument to an invocation, and the AST structure
|
| - * has been resolved, and the function being invoked is known based on static
|
| - * type information, and this expression corresponds to one of the parameters
|
| - * of the function being invoked, then return the parameter element
|
| - * representing the parameter to which the value of this expression will be
|
| - * bound. Otherwise, return `null`.
|
| - */
|
| - ParameterElement get staticParameterElement {
|
| - AstNode parent = this.parent;
|
| - if (parent is ArgumentList) {
|
| - return parent._getStaticParameterElementFor(this);
|
| - } else if (parent is IndexExpression) {
|
| - IndexExpression indexExpression = parent;
|
| - if (identical(indexExpression.index, this)) {
|
| - return indexExpression._staticParameterElementForIndex;
|
| - }
|
| - } else if (parent is BinaryExpression) {
|
| - BinaryExpression binaryExpression = parent;
|
| - if (identical(binaryExpression.rightOperand, this)) {
|
| - return binaryExpression._staticParameterElementForRightOperand;
|
| - }
|
| - } else if (parent is AssignmentExpression) {
|
| - AssignmentExpression assignmentExpression = parent;
|
| - if (identical(assignmentExpression.rightHandSide, this)) {
|
| - return assignmentExpression._staticParameterElementForRightHandSide;
|
| - }
|
| - } else if (parent is PrefixExpression) {
|
| - return parent._staticParameterElementForOperand;
|
| - } else if (parent is PostfixExpression) {
|
| - return parent._staticParameterElementForOperand;
|
| - }
|
| - return null;
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A function body consisting of a single expression.
|
| - *
|
| - * > expressionFunctionBody ::=
|
| - * > 'async'? '=>' [Expression] ';'
|
| - */
|
| -class ExpressionFunctionBody extends FunctionBody {
|
| - /**
|
| - * The token representing the 'async' keyword, or `null` if there is no such
|
| - * keyword.
|
| - */
|
| - Token keyword;
|
| -
|
| - /**
|
| - * The token introducing the expression that represents the body of the
|
| - * function.
|
| - */
|
| - Token functionDefinition;
|
| -
|
| - /**
|
| - * The expression representing the body of the function.
|
| - */
|
| - Expression _expression;
|
| -
|
| - /**
|
| - * The semicolon terminating the statement.
|
| - */
|
| - Token semicolon;
|
| -
|
| - /**
|
| - * Initialize a newly created function body consisting of a block of
|
| - * statements. The [keyword] can be `null` if the function body is not an
|
| - * async function body.
|
| - */
|
| - ExpressionFunctionBody(this.keyword, this.functionDefinition,
|
| - Expression expression, this.semicolon) {
|
| - _expression = _becomeParentOf(expression);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken {
|
| - if (keyword != null) {
|
| - return keyword;
|
| - }
|
| - return functionDefinition;
|
| - }
|
| -
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()
|
| - ..add(keyword)
|
| - ..add(functionDefinition)
|
| - ..add(_expression)
|
| - ..add(semicolon);
|
| -
|
| - @override
|
| - Token get endToken {
|
| - if (semicolon != null) {
|
| - return semicolon;
|
| - }
|
| - return _expression.endToken;
|
| - }
|
| -
|
| - /**
|
| - * Return the expression representing the body of the function.
|
| - */
|
| - Expression get expression => _expression;
|
| -
|
| - /**
|
| - * Set the expression representing the body of the function to the given
|
| - * [expression].
|
| - */
|
| - void set expression(Expression expression) {
|
| - _expression = _becomeParentOf(expression);
|
| - }
|
| -
|
| - @override
|
| - bool get isAsynchronous => keyword != null;
|
| -
|
| - @override
|
| - bool get isSynchronous => keyword == null;
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitExpressionFunctionBody(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_expression, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * An expression used as a statement.
|
| - *
|
| - * > expressionStatement ::=
|
| - * > [Expression]? ';'
|
| - */
|
| -class ExpressionStatement extends Statement {
|
| - /**
|
| - * The expression that comprises the statement.
|
| - */
|
| - Expression _expression;
|
| -
|
| - /**
|
| - * The semicolon terminating the statement, or `null` if the expression is a
|
| - * function expression and therefore isn't followed by a semicolon.
|
| - */
|
| - Token semicolon;
|
| -
|
| - /**
|
| - * Initialize a newly created expression statement.
|
| - */
|
| - ExpressionStatement(Expression expression, this.semicolon) {
|
| - _expression = _becomeParentOf(expression);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => _expression.beginToken;
|
| -
|
| - @override
|
| - Iterable get childEntities =>
|
| - new ChildEntities()..add(_expression)..add(semicolon);
|
| -
|
| - @override
|
| - Token get endToken {
|
| - if (semicolon != null) {
|
| - return semicolon;
|
| - }
|
| - return _expression.endToken;
|
| - }
|
| -
|
| - /**
|
| - * Return the expression that comprises the statement.
|
| - */
|
| - Expression get expression => _expression;
|
| -
|
| - /**
|
| - * Set the expression that comprises the statement to the given [expression].
|
| - */
|
| - void set expression(Expression expression) {
|
| - _expression = _becomeParentOf(expression);
|
| - }
|
| -
|
| - @override
|
| - bool get isSynthetic => _expression.isSynthetic && semicolon.isSynthetic;
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitExpressionStatement(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_expression, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * The "extends" clause in a class declaration.
|
| - *
|
| - * > extendsClause ::=
|
| - * > 'extends' [TypeName]
|
| - */
|
| -class ExtendsClause extends AstNode {
|
| - /**
|
| - * The token representing the 'extends' keyword.
|
| - */
|
| - Token extendsKeyword;
|
| -
|
| - /**
|
| - * The name of the class that is being extended.
|
| - */
|
| - TypeName _superclass;
|
| -
|
| - /**
|
| - * Initialize a newly created extends clause.
|
| - */
|
| - ExtendsClause(this.extendsKeyword, TypeName superclass) {
|
| - _superclass = _becomeParentOf(superclass);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => extendsKeyword;
|
| -
|
| - @override
|
| - Iterable get childEntities =>
|
| - new ChildEntities()..add(extendsKeyword)..add(_superclass);
|
| -
|
| - @override
|
| - Token get endToken => _superclass.endToken;
|
| -
|
| - /**
|
| - * Return the token for the 'extends' keyword.
|
| - */
|
| - @deprecated // Use "this.extendsKeyword"
|
| - Token get keyword => extendsKeyword;
|
| -
|
| - /**
|
| - * Set the token for the 'extends' keyword to the given [token].
|
| - */
|
| - @deprecated // Use "this.extendsKeyword"
|
| - set keyword(Token token) {
|
| - extendsKeyword = token;
|
| - }
|
| -
|
| - /**
|
| - * Return the name of the class that is being extended.
|
| - */
|
| - TypeName get superclass => _superclass;
|
| -
|
| - /**
|
| - * Set the name of the class that is being extended to the given [name].
|
| - */
|
| - void set superclass(TypeName name) {
|
| - _superclass = _becomeParentOf(name);
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitExtendsClause(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_superclass, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * The declaration of one or more fields of the same type.
|
| - *
|
| - * > fieldDeclaration ::=
|
| - * > 'static'? [VariableDeclarationList] ';'
|
| - */
|
| -class FieldDeclaration extends ClassMember {
|
| - /**
|
| - * The token representing the 'static' keyword, or `null` if the fields are
|
| - * not static.
|
| - */
|
| - Token staticKeyword;
|
| -
|
| - /**
|
| - * The fields being declared.
|
| - */
|
| - VariableDeclarationList _fieldList;
|
| -
|
| - /**
|
| - * The semicolon terminating the declaration.
|
| - */
|
| - Token semicolon;
|
| -
|
| - /**
|
| - * Initialize a newly created field declaration. Either or both of the
|
| - * [comment] and [metadata] can be `null` if the declaration does not have the
|
| - * corresponding attribute. The [staticKeyword] can be `null` if the field is
|
| - * not a static field.
|
| - */
|
| - FieldDeclaration(Comment comment, List<Annotation> metadata,
|
| - this.staticKeyword, VariableDeclarationList fieldList, this.semicolon)
|
| - : super(comment, metadata) {
|
| - _fieldList = _becomeParentOf(fieldList);
|
| - }
|
| -
|
| - @override
|
| - Iterable get childEntities =>
|
| - super._childEntities..add(staticKeyword)..add(_fieldList)..add(semicolon);
|
| -
|
| - @override
|
| - Element get element => null;
|
| -
|
| - @override
|
| - Token get endToken => semicolon;
|
| -
|
| - /**
|
| - * Return the fields being declared.
|
| - */
|
| - VariableDeclarationList get fields => _fieldList;
|
| -
|
| - /**
|
| - * Set the fields being declared to the given list of [fields].
|
| - */
|
| - void set fields(VariableDeclarationList fields) {
|
| - _fieldList = _becomeParentOf(fields);
|
| - }
|
| -
|
| - @override
|
| - Token get firstTokenAfterCommentAndMetadata {
|
| - if (staticKeyword != null) {
|
| - return staticKeyword;
|
| - }
|
| - return _fieldList.beginToken;
|
| - }
|
| -
|
| - /**
|
| - * Return `true` if the fields are declared to be static.
|
| - */
|
| - bool get isStatic => staticKeyword != null;
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitFieldDeclaration(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - super.visitChildren(visitor);
|
| - _safelyVisitChild(_fieldList, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A field formal parameter.
|
| - *
|
| - * > fieldFormalParameter ::=
|
| - * > ('final' [TypeName] | 'const' [TypeName] | 'var' | [TypeName])?
|
| - * > 'this' '.' [SimpleIdentifier] ([TypeParameterList]? [FormalParameterList])?
|
| - */
|
| -class FieldFormalParameter extends NormalFormalParameter {
|
| - /**
|
| - * The token representing either the 'final', 'const' or 'var' keyword, or
|
| - * `null` if no keyword was used.
|
| - */
|
| - Token keyword;
|
| -
|
| - /**
|
| - * The name of the declared type of the parameter, or `null` if the parameter
|
| - * does not have a declared type.
|
| - */
|
| - TypeName _type;
|
| -
|
| - /**
|
| - * The token representing the 'this' keyword.
|
| - */
|
| - Token thisKeyword;
|
| -
|
| - /**
|
| - * The token representing the period.
|
| - */
|
| - Token period;
|
| -
|
| - /**
|
| - * The type parameters associated with the method, or `null` if the method is
|
| - * not a generic method.
|
| - */
|
| - TypeParameterList _typeParameters;
|
| -
|
| - /**
|
| - * The parameters of the function-typed parameter, or `null` if this is not a
|
| - * function-typed field formal parameter.
|
| - */
|
| - FormalParameterList _parameters;
|
| -
|
| - /**
|
| - * Initialize a newly created formal parameter. Either or both of the
|
| - * [comment] and [metadata] can be `null` if the parameter does not have the
|
| - * corresponding attribute. The [keyword] can be `null` if there is a type.
|
| - * The [type] must be `null` if the keyword is 'var'. The [thisKeyword] and
|
| - * [period] can be `null` if the keyword 'this' was not provided. The
|
| - * [parameters] can be `null` if this is not a function-typed field formal
|
| - * parameter.
|
| - */
|
| - FieldFormalParameter(Comment comment, List<Annotation> metadata, this.keyword,
|
| - TypeName type, this.thisKeyword, this.period, SimpleIdentifier identifier,
|
| - TypeParameterList typeParameters, FormalParameterList parameters)
|
| - : super(comment, metadata, identifier) {
|
| - _type = _becomeParentOf(type);
|
| - _typeParameters = _becomeParentOf(typeParameters);
|
| - _parameters = _becomeParentOf(parameters);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken {
|
| - if (keyword != null) {
|
| - return keyword;
|
| - } else if (_type != null) {
|
| - return _type.beginToken;
|
| - }
|
| - return thisKeyword;
|
| - }
|
| -
|
| - @override
|
| - Iterable get childEntities => super._childEntities
|
| - ..add(keyword)
|
| - ..add(_type)
|
| - ..add(thisKeyword)
|
| - ..add(period)
|
| - ..add(identifier)
|
| - ..add(_parameters);
|
| -
|
| - @override
|
| - Token get endToken {
|
| - if (_parameters != null) {
|
| - return _parameters.endToken;
|
| - }
|
| - return identifier.endToken;
|
| - }
|
| -
|
| - @override
|
| - bool get isConst => (keyword is KeywordToken) &&
|
| - (keyword as KeywordToken).keyword == Keyword.CONST;
|
| -
|
| - @override
|
| - bool get isFinal => (keyword is KeywordToken) &&
|
| - (keyword as KeywordToken).keyword == Keyword.FINAL;
|
| -
|
| - /**
|
| - * Return the parameters of the function-typed parameter, or `null` if this is
|
| - * not a function-typed field formal parameter.
|
| - */
|
| - FormalParameterList get parameters => _parameters;
|
| -
|
| - /**
|
| - * Set the parameters of the function-typed parameter to the given
|
| - * [parameters].
|
| - */
|
| - void set parameters(FormalParameterList parameters) {
|
| - _parameters = _becomeParentOf(parameters);
|
| - }
|
| -
|
| - /**
|
| - * Return the token representing the 'this' keyword.
|
| - */
|
| - @deprecated // Use "this.thisKeyword"
|
| - Token get thisToken => thisKeyword;
|
| -
|
| - /**
|
| - * Set the token representing the 'this' keyword to the given [token].
|
| - */
|
| - @deprecated // Use "this.thisKeyword"
|
| - set thisToken(Token token) {
|
| - thisKeyword = token;
|
| - }
|
| -
|
| - /**
|
| - * Return the name of the declared type of the parameter, or `null` if the
|
| - * parameter does not have a declared type. Note that if this is a
|
| - * function-typed field formal parameter this is the return type of the
|
| - * function.
|
| - */
|
| - TypeName get type => _type;
|
| -
|
| - /**
|
| - * Set the name of the declared type of the parameter to the given [typeName].
|
| - */
|
| - void set type(TypeName typeName) {
|
| - _type = _becomeParentOf(typeName);
|
| - }
|
| -
|
| - /**
|
| - * Return the type parameters associated with this method, or `null` if this
|
| - * method is not a generic method.
|
| - */
|
| - TypeParameterList get typeParameters => _typeParameters;
|
| -
|
| - /**
|
| - * Set the type parameters associated with this method to the given
|
| - * [typeParameters].
|
| - */
|
| - void set typeParameters(TypeParameterList typeParameters) {
|
| - _typeParameters = _becomeParentOf(typeParameters);
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitFieldFormalParameter(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - super.visitChildren(visitor);
|
| - _safelyVisitChild(_type, visitor);
|
| - _safelyVisitChild(identifier, visitor);
|
| - _safelyVisitChild(_typeParameters, visitor);
|
| - _safelyVisitChild(_parameters, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A for-each statement.
|
| - *
|
| - * > forEachStatement ::=
|
| - * > 'await'? 'for' '(' [DeclaredIdentifier] 'in' [Expression] ')' [Block]
|
| - * > | 'await'? 'for' '(' [SimpleIdentifier] 'in' [Expression] ')' [Block]
|
| - */
|
| -class ForEachStatement extends Statement {
|
| - /**
|
| - * The token representing the 'await' keyword, or `null` if there is no
|
| - * 'await' keyword.
|
| - */
|
| - Token awaitKeyword;
|
| -
|
| - /**
|
| - * The token representing the 'for' keyword.
|
| - */
|
| - Token forKeyword;
|
| -
|
| - /**
|
| - * The left parenthesis.
|
| - */
|
| - Token leftParenthesis;
|
| -
|
| - /**
|
| - * The declaration of the loop variable, or `null` if the loop variable is a
|
| - * simple identifier.
|
| - */
|
| - DeclaredIdentifier _loopVariable;
|
| -
|
| - /**
|
| - * The loop variable, or `null` if the loop variable is declared in the 'for'.
|
| - */
|
| - SimpleIdentifier _identifier;
|
| -
|
| - /**
|
| - * The token representing the 'in' keyword.
|
| - */
|
| - Token inKeyword;
|
| -
|
| - /**
|
| - * The expression evaluated to produce the iterator.
|
| - */
|
| - Expression _iterable;
|
| -
|
| - /**
|
| - * The right parenthesis.
|
| - */
|
| - Token rightParenthesis;
|
| -
|
| - /**
|
| - * The body of the loop.
|
| - */
|
| - Statement _body;
|
| -
|
| - /**
|
| - * Initialize a newly created for-each statement. The [awaitKeyword] can be
|
| - * `null` if this is not an asynchronous for loop.
|
| - */
|
| - @deprecated // Use new ForEachStatement.withDeclaration(...)
|
| - ForEachStatement.con1(this.awaitKeyword, this.forKeyword,
|
| - this.leftParenthesis, DeclaredIdentifier loopVariable, this.inKeyword,
|
| - Expression iterator, this.rightParenthesis, Statement body) {
|
| - _loopVariable = _becomeParentOf(loopVariable);
|
| - _iterable = _becomeParentOf(iterator);
|
| - _body = _becomeParentOf(body);
|
| - }
|
| -
|
| - /**
|
| - * Initialize a newly created for-each statement. The [awaitKeyword] can be
|
| - * `null` if this is not an asynchronous for loop.
|
| - */
|
| - @deprecated // Use new ForEachStatement.withReference(...)
|
| - ForEachStatement.con2(this.awaitKeyword, this.forKeyword,
|
| - this.leftParenthesis, SimpleIdentifier identifier, this.inKeyword,
|
| - Expression iterator, this.rightParenthesis, Statement body) {
|
| - _identifier = _becomeParentOf(identifier);
|
| - _iterable = _becomeParentOf(iterator);
|
| - _body = _becomeParentOf(body);
|
| - }
|
| -
|
| - /**
|
| - * Initialize a newly created for-each statement whose loop control variable
|
| - * is declared internally (in the for-loop part). The [awaitKeyword] can be
|
| - * `null` if this is not an asynchronous for loop.
|
| - */
|
| - ForEachStatement.withDeclaration(this.awaitKeyword, this.forKeyword,
|
| - this.leftParenthesis, DeclaredIdentifier loopVariable, this.inKeyword,
|
| - Expression iterator, this.rightParenthesis, Statement body) {
|
| - _loopVariable = _becomeParentOf(loopVariable);
|
| - _iterable = _becomeParentOf(iterator);
|
| - _body = _becomeParentOf(body);
|
| - }
|
| -
|
| - /**
|
| - * Initialize a newly created for-each statement whose loop control variable
|
| - * is declared outside the for loop. The [awaitKeyword] can be `null` if this
|
| - * is not an asynchronous for loop.
|
| - */
|
| - ForEachStatement.withReference(this.awaitKeyword, this.forKeyword,
|
| - this.leftParenthesis, SimpleIdentifier identifier, this.inKeyword,
|
| - Expression iterator, this.rightParenthesis, Statement body) {
|
| - _identifier = _becomeParentOf(identifier);
|
| - _iterable = _becomeParentOf(iterator);
|
| - _body = _becomeParentOf(body);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => forKeyword;
|
| -
|
| - /**
|
| - * Return the body of the loop.
|
| - */
|
| - Statement get body => _body;
|
| -
|
| - /**
|
| - * Set the body of the loop to the given [statement].
|
| - */
|
| - void set body(Statement statement) {
|
| - _body = _becomeParentOf(statement);
|
| - }
|
| -
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()
|
| - ..add(awaitKeyword)
|
| - ..add(forKeyword)
|
| - ..add(leftParenthesis)
|
| - ..add(_loopVariable)
|
| - ..add(_identifier)
|
| - ..add(inKeyword)
|
| - ..add(_iterable)
|
| - ..add(rightParenthesis)
|
| - ..add(_body);
|
| -
|
| - @override
|
| - Token get endToken => _body.endToken;
|
| -
|
| - /**
|
| - * Return the loop variable, or `null` if the loop variable is declared in the
|
| - * 'for'.
|
| - */
|
| - SimpleIdentifier get identifier => _identifier;
|
| -
|
| - /**
|
| - * Set the loop variable to the given [identifier].
|
| - */
|
| - void set identifier(SimpleIdentifier identifier) {
|
| - _identifier = _becomeParentOf(identifier);
|
| - }
|
| -
|
| - /**
|
| - * Return the expression evaluated to produce the iterator.
|
| - */
|
| - Expression get iterable => _iterable;
|
| -
|
| - /**
|
| - * Set the expression evaluated to produce the iterator to the given
|
| - * [expression].
|
| - */
|
| - void set iterable(Expression expression) {
|
| - _iterable = _becomeParentOf(expression);
|
| - }
|
| -
|
| - /**
|
| - * Return the expression evaluated to produce the iterator.
|
| - */
|
| - @deprecated // Use "this.iterable"
|
| - Expression get iterator => iterable;
|
| -
|
| - /**
|
| - * Return the declaration of the loop variable, or `null` if the loop variable
|
| - * is a simple identifier.
|
| - */
|
| - DeclaredIdentifier get loopVariable => _loopVariable;
|
| -
|
| - /**
|
| - * Set the declaration of the loop variable to the given [variable].
|
| - */
|
| - void set loopVariable(DeclaredIdentifier variable) {
|
| - _loopVariable = _becomeParentOf(variable);
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitForEachStatement(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_loopVariable, visitor);
|
| - _safelyVisitChild(_identifier, visitor);
|
| - _safelyVisitChild(_iterable, visitor);
|
| - _safelyVisitChild(_body, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A node representing a parameter to a function.
|
| - *
|
| - * > formalParameter ::=
|
| - * > [NormalFormalParameter]
|
| - * > | [DefaultFormalParameter]
|
| - */
|
| -abstract class FormalParameter extends AstNode {
|
| - /**
|
| - * Return the element representing this parameter, or `null` if this parameter
|
| - * has not been resolved.
|
| - */
|
| - ParameterElement get element {
|
| - SimpleIdentifier identifier = this.identifier;
|
| - if (identifier == null) {
|
| - return null;
|
| - }
|
| - return identifier.staticElement as ParameterElement;
|
| - }
|
| -
|
| - /**
|
| - * Return the name of the parameter being declared.
|
| - */
|
| - SimpleIdentifier get identifier;
|
| -
|
| - /**
|
| - * Return `true` if this parameter was declared with the 'const' modifier.
|
| - */
|
| - bool get isConst;
|
| -
|
| - /**
|
| - * Return `true` if this parameter was declared with the 'final' modifier.
|
| - * Parameters that are declared with the 'const' modifier will return `false`
|
| - * even though they are implicitly final.
|
| - */
|
| - bool get isFinal;
|
| -
|
| - /**
|
| - * Return the kind of this parameter.
|
| - */
|
| - ParameterKind get kind;
|
| -}
|
| -
|
| -/**
|
| - * The formal parameter list of a method declaration, function declaration, or
|
| - * function type alias.
|
| - *
|
| - * While the grammar requires all optional formal parameters to follow all of
|
| - * the normal formal parameters and at most one grouping of optional formal
|
| - * parameters, this class does not enforce those constraints. All parameters are
|
| - * flattened into a single list, which can have any or all kinds of parameters
|
| - * (normal, named, and positional) in any order.
|
| - *
|
| - * > formalParameterList ::=
|
| - * > '(' ')'
|
| - * > | '(' normalFormalParameters (',' optionalFormalParameters)? ')'
|
| - * > | '(' optionalFormalParameters ')'
|
| - * >
|
| - * > normalFormalParameters ::=
|
| - * > [NormalFormalParameter] (',' [NormalFormalParameter])*
|
| - * >
|
| - * > optionalFormalParameters ::=
|
| - * > optionalPositionalFormalParameters
|
| - * > | namedFormalParameters
|
| - * >
|
| - * > optionalPositionalFormalParameters ::=
|
| - * > '[' [DefaultFormalParameter] (',' [DefaultFormalParameter])* ']'
|
| - * >
|
| - * > namedFormalParameters ::=
|
| - * > '{' [DefaultFormalParameter] (',' [DefaultFormalParameter])* '}'
|
| - */
|
| -class FormalParameterList extends AstNode {
|
| - /**
|
| - * The left parenthesis.
|
| - */
|
| - Token leftParenthesis;
|
| -
|
| - /**
|
| - * The parameters associated with the method.
|
| - */
|
| - NodeList<FormalParameter> _parameters;
|
| -
|
| - /**
|
| - * The left square bracket ('[') or left curly brace ('{') introducing the
|
| - * optional parameters, or `null` if there are no optional parameters.
|
| - */
|
| - Token leftDelimiter;
|
| -
|
| - /**
|
| - * The right square bracket (']') or right curly brace ('}') terminating the
|
| - * optional parameters, or `null` if there are no optional parameters.
|
| - */
|
| - Token rightDelimiter;
|
| -
|
| - /**
|
| - * The right parenthesis.
|
| - */
|
| - Token rightParenthesis;
|
| -
|
| - /**
|
| - * Initialize a newly created parameter list. The list of [parameters] can be
|
| - * `null` if there are no parameters. The [leftDelimiter] and [rightDelimiter]
|
| - * can be `null` if there are no optional parameters.
|
| - */
|
| - FormalParameterList(this.leftParenthesis, List<FormalParameter> parameters,
|
| - this.leftDelimiter, this.rightDelimiter, this.rightParenthesis) {
|
| - _parameters = new NodeList<FormalParameter>(this, parameters);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => leftParenthesis;
|
| -
|
| - @override
|
| - Iterable get childEntities {
|
| - // TODO(paulberry): include commas.
|
| - ChildEntities result = new ChildEntities()..add(leftParenthesis);
|
| - bool leftDelimiterNeeded = leftDelimiter != null;
|
| - for (FormalParameter parameter in _parameters) {
|
| - if (leftDelimiterNeeded && leftDelimiter.offset < parameter.offset) {
|
| - result.add(leftDelimiter);
|
| - leftDelimiterNeeded = false;
|
| - }
|
| - result.add(parameter);
|
| - }
|
| - return result..add(rightDelimiter)..add(rightParenthesis);
|
| - }
|
| -
|
| - @override
|
| - Token get endToken => rightParenthesis;
|
| -
|
| - /**
|
| - * Return a list containing the elements representing the parameters in this
|
| - * list. The list will contain `null`s if the parameters in this list have not
|
| - * been resolved.
|
| - */
|
| - List<ParameterElement> get parameterElements {
|
| - int count = _parameters.length;
|
| - List<ParameterElement> types = new List<ParameterElement>(count);
|
| - for (int i = 0; i < count; i++) {
|
| - types[i] = _parameters[i].element;
|
| - }
|
| - return types;
|
| - }
|
| -
|
| - /**
|
| - * Return the parameters associated with the method.
|
| - */
|
| - NodeList<FormalParameter> get parameters => _parameters;
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitFormalParameterList(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _parameters.accept(visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A for statement.
|
| - *
|
| - * > forStatement ::=
|
| - * > 'for' '(' forLoopParts ')' [Statement]
|
| - * >
|
| - * > forLoopParts ::=
|
| - * > forInitializerStatement ';' [Expression]? ';' [Expression]?
|
| - * >
|
| - * > forInitializerStatement ::=
|
| - * > [DefaultFormalParameter]
|
| - * > | [Expression]?
|
| - */
|
| -class ForStatement extends Statement {
|
| - /**
|
| - * The token representing the 'for' keyword.
|
| - */
|
| - Token forKeyword;
|
| -
|
| - /**
|
| - * The left parenthesis.
|
| - */
|
| - Token leftParenthesis;
|
| -
|
| - /**
|
| - * The declaration of the loop variables, or `null` if there are no variables.
|
| - * Note that a for statement cannot have both a variable list and an
|
| - * initialization expression, but can validly have neither.
|
| - */
|
| - VariableDeclarationList _variableList;
|
| -
|
| - /**
|
| - * The initialization expression, or `null` if there is no initialization
|
| - * expression. Note that a for statement cannot have both a variable list and
|
| - * an initialization expression, but can validly have neither.
|
| - */
|
| - Expression _initialization;
|
| -
|
| - /**
|
| - * The semicolon separating the initializer and the condition.
|
| - */
|
| - Token leftSeparator;
|
| -
|
| - /**
|
| - * The condition used to determine when to terminate the loop, or `null` if
|
| - * there is no condition.
|
| - */
|
| - Expression _condition;
|
| -
|
| - /**
|
| - * The semicolon separating the condition and the updater.
|
| - */
|
| - Token rightSeparator;
|
| -
|
| - /**
|
| - * The list of expressions run after each execution of the loop body.
|
| - */
|
| - NodeList<Expression> _updaters;
|
| -
|
| - /**
|
| - * The right parenthesis.
|
| - */
|
| - Token rightParenthesis;
|
| -
|
| - /**
|
| - * The body of the loop.
|
| - */
|
| - Statement _body;
|
| -
|
| - /**
|
| - * Initialize a newly created for statement. Either the [variableList] or the
|
| - * [initialization] must be `null`. Either the [condition] and the list of
|
| - * [updaters] can be `null` if the loop does not have the corresponding
|
| - * attribute.
|
| - */
|
| - ForStatement(this.forKeyword, this.leftParenthesis,
|
| - VariableDeclarationList variableList, Expression initialization,
|
| - this.leftSeparator, Expression condition, this.rightSeparator,
|
| - List<Expression> updaters, this.rightParenthesis, Statement body) {
|
| - _variableList = _becomeParentOf(variableList);
|
| - _initialization = _becomeParentOf(initialization);
|
| - _condition = _becomeParentOf(condition);
|
| - _updaters = new NodeList<Expression>(this, updaters);
|
| - _body = _becomeParentOf(body);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => forKeyword;
|
| -
|
| - /**
|
| - * Return the body of the loop.
|
| - */
|
| - Statement get body => _body;
|
| -
|
| - /**
|
| - * Set the body of the loop to the given [statement].
|
| - */
|
| - void set body(Statement statement) {
|
| - _body = _becomeParentOf(statement);
|
| - }
|
| -
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()
|
| - ..add(forKeyword)
|
| - ..add(leftParenthesis)
|
| - ..add(_variableList)
|
| - ..add(_initialization)
|
| - ..add(leftSeparator)
|
| - ..add(_condition)
|
| - ..add(rightSeparator)
|
| - ..addAll(_updaters)
|
| - ..add(rightParenthesis)
|
| - ..add(_body);
|
| -
|
| - /**
|
| - * Return the condition used to determine when to terminate the loop, or
|
| - * `null` if there is no condition.
|
| - */
|
| - Expression get condition => _condition;
|
| -
|
| - /**
|
| - * Set the condition used to determine when to terminate the loop to the given
|
| - * [expression].
|
| - */
|
| - void set condition(Expression expression) {
|
| - _condition = _becomeParentOf(expression);
|
| - }
|
| -
|
| - @override
|
| - Token get endToken => _body.endToken;
|
| -
|
| - /**
|
| - * Return the initialization expression, or `null` if there is no
|
| - * initialization expression.
|
| - */
|
| - Expression get initialization => _initialization;
|
| -
|
| - /**
|
| - * Set the initialization expression to the given [expression].
|
| - */
|
| - void set initialization(Expression initialization) {
|
| - _initialization = _becomeParentOf(initialization);
|
| - }
|
| -
|
| - /**
|
| - * Return the list of expressions run after each execution of the loop body.
|
| - */
|
| - NodeList<Expression> get updaters => _updaters;
|
| -
|
| - /**
|
| - * Return the declaration of the loop variables, or `null` if there are no
|
| - * variables.
|
| - */
|
| - VariableDeclarationList get variables => _variableList;
|
| -
|
| - /**
|
| - * Set the declaration of the loop variables to the given [variableList].
|
| - */
|
| - void set variables(VariableDeclarationList variableList) {
|
| - _variableList = _becomeParentOf(variableList);
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitForStatement(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_variableList, visitor);
|
| - _safelyVisitChild(_initialization, visitor);
|
| - _safelyVisitChild(_condition, visitor);
|
| - _updaters.accept(visitor);
|
| - _safelyVisitChild(_body, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A node representing the body of a function or method.
|
| - *
|
| - * > functionBody ::=
|
| - * > [BlockFunctionBody]
|
| - * > | [EmptyFunctionBody]
|
| - * > | [ExpressionFunctionBody]
|
| - */
|
| -abstract class FunctionBody extends AstNode {
|
| - /**
|
| - * Return `true` if this function body is asynchronous.
|
| - */
|
| - bool get isAsynchronous => false;
|
| -
|
| - /**
|
| - * Return `true` if this function body is a generator.
|
| - */
|
| - bool get isGenerator => false;
|
| -
|
| - /**
|
| - * Return `true` if this function body is synchronous.
|
| - */
|
| - bool get isSynchronous => true;
|
| -
|
| - /**
|
| - * Return the token representing the 'async' or 'sync' keyword, or `null` if
|
| - * there is no such keyword.
|
| - */
|
| - Token get keyword => null;
|
| -
|
| - /**
|
| - * Return the star following the 'async' or 'sync' keyword, or `null` if there
|
| - * is no star.
|
| - */
|
| - Token get star => null;
|
| -}
|
| -
|
| -/**
|
| - * A top-level declaration.
|
| - *
|
| - * > functionDeclaration ::=
|
| - * > 'external' functionSignature
|
| - * > | functionSignature [FunctionBody]
|
| - * >
|
| - * > functionSignature ::=
|
| - * > [Type]? ('get' | 'set')? [SimpleIdentifier] [FormalParameterList]
|
| - */
|
| -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 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, name) {
|
| - _returnType = _becomeParentOf(returnType);
|
| - _functionExpression = _becomeParentOf(functionExpression);
|
| - }
|
| -
|
| - @override
|
| - Iterable get childEntities => super._childEntities
|
| - ..add(externalKeyword)
|
| - ..add(_returnType)
|
| - ..add(propertyKeyword)
|
| - ..add(_name)
|
| - ..add(_functionExpression);
|
| -
|
| - @override
|
| - ExecutableElement get element =>
|
| - _name != null ? (_name.staticElement as ExecutableElement) : null;
|
| -
|
| - @override
|
| - Token get endToken => _functionExpression.endToken;
|
| -
|
| - @override
|
| - Token get firstTokenAfterCommentAndMetadata {
|
| - if (externalKeyword != null) {
|
| - return externalKeyword;
|
| - } else if (_returnType != null) {
|
| - return _returnType.beginToken;
|
| - } else if (propertyKeyword != null) {
|
| - return propertyKeyword;
|
| - } else if (_name != null) {
|
| - return _name.beginToken;
|
| - }
|
| - return _functionExpression.beginToken;
|
| - }
|
| -
|
| - /**
|
| - * Return the function expression being wrapped.
|
| - */
|
| - FunctionExpression get functionExpression => _functionExpression;
|
| -
|
| - /**
|
| - * Set the function expression being wrapped to the given
|
| - * [functionExpression].
|
| - */
|
| - void set functionExpression(FunctionExpression functionExpression) {
|
| - _functionExpression = _becomeParentOf(functionExpression);
|
| - }
|
| -
|
| - /**
|
| - * Return `true` if this function declares a getter.
|
| - */
|
| - 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 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);
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitFunctionDeclaration(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - super.visitChildren(visitor);
|
| - _safelyVisitChild(_returnType, visitor);
|
| - _safelyVisitChild(_name, visitor);
|
| - _safelyVisitChild(_functionExpression, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A [FunctionDeclaration] used as a statement.
|
| - */
|
| -class FunctionDeclarationStatement extends Statement {
|
| - /**
|
| - * The function declaration being wrapped.
|
| - */
|
| - FunctionDeclaration _functionDeclaration;
|
| -
|
| - /**
|
| - * Initialize a newly created function declaration statement.
|
| - */
|
| - FunctionDeclarationStatement(FunctionDeclaration functionDeclaration) {
|
| - _functionDeclaration = _becomeParentOf(functionDeclaration);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => _functionDeclaration.beginToken;
|
| -
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()..add(_functionDeclaration);
|
| -
|
| - @override
|
| - Token get endToken => _functionDeclaration.endToken;
|
| -
|
| - /**
|
| - * Return the function declaration being wrapped.
|
| - */
|
| - FunctionDeclaration get functionDeclaration => _functionDeclaration;
|
| -
|
| - /**
|
| - * Set the function declaration being wrapped to the given
|
| - * [functionDeclaration].
|
| - */
|
| - void set functionDeclaration(FunctionDeclaration functionDeclaration) {
|
| - _functionDeclaration = _becomeParentOf(functionDeclaration);
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitFunctionDeclarationStatement(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_functionDeclaration, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A function expression.
|
| - *
|
| - * > functionExpression ::=
|
| - * > [TypeParameterList]? [FormalParameterList] [FunctionBody]
|
| - */
|
| -class FunctionExpression extends Expression {
|
| - /**
|
| - * The type parameters associated with the method, or `null` if the method is
|
| - * not a generic method.
|
| - */
|
| - TypeParameterList _typeParameters;
|
| -
|
| - /**
|
| - * The parameters associated with the function.
|
| - */
|
| - FormalParameterList _parameters;
|
| -
|
| - /**
|
| - * The body of the function, or `null` if this is an external function.
|
| - */
|
| - FunctionBody _body;
|
| -
|
| - /**
|
| - * The element associated with the function, or `null` if the AST structure
|
| - * has not been resolved.
|
| - */
|
| - ExecutableElement element;
|
| -
|
| - /**
|
| - * Initialize a newly created function declaration.
|
| - */
|
| - FunctionExpression(TypeParameterList typeParameters,
|
| - FormalParameterList parameters, FunctionBody body) {
|
| - _typeParameters = _becomeParentOf(typeParameters);
|
| - _parameters = _becomeParentOf(parameters);
|
| - _body = _becomeParentOf(body);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken {
|
| - if (_typeParameters != null) {
|
| - return _typeParameters.beginToken;
|
| - } else if (_parameters != null) {
|
| - return _parameters.beginToken;
|
| - } else if (_body != null) {
|
| - return _body.beginToken;
|
| - }
|
| - // This should never be reached because external functions must be named,
|
| - // hence either the body or the name should be non-null.
|
| - throw new IllegalStateException("Non-external functions must have a body");
|
| - }
|
| -
|
| - /**
|
| - * Return the body of the function, or `null` if this is an external function.
|
| - */
|
| - FunctionBody get body => _body;
|
| -
|
| - /**
|
| - * Set the body of the function to the given [functionBody].
|
| - */
|
| - void set body(FunctionBody functionBody) {
|
| - _body = _becomeParentOf(functionBody);
|
| - }
|
| -
|
| - @override
|
| - Iterable get childEntities =>
|
| - new ChildEntities()..add(_parameters)..add(_body);
|
| -
|
| - @override
|
| - Token get endToken {
|
| - if (_body != null) {
|
| - return _body.endToken;
|
| - } else if (_parameters != null) {
|
| - return _parameters.endToken;
|
| - }
|
| - // This should never be reached because external functions must be named,
|
| - // hence either the body or the name should be non-null.
|
| - throw new IllegalStateException("Non-external functions must have a body");
|
| - }
|
| -
|
| - /**
|
| - * Return the parameters associated with the function.
|
| - */
|
| - FormalParameterList get parameters => _parameters;
|
| -
|
| - /**
|
| - * Set the parameters associated with the function to the given list of
|
| - * [parameters].
|
| - */
|
| - void set parameters(FormalParameterList parameters) {
|
| - _parameters = _becomeParentOf(parameters);
|
| - }
|
| -
|
| - @override
|
| - int get precedence => 16;
|
| -
|
| - /**
|
| - * Return the type parameters associated with this method, or `null` if this
|
| - * method is not a generic method.
|
| - */
|
| - TypeParameterList get typeParameters => _typeParameters;
|
| -
|
| - /**
|
| - * Set the type parameters associated with this method to the given
|
| - * [typeParameters].
|
| - */
|
| - void set typeParameters(TypeParameterList typeParameters) {
|
| - _typeParameters = _becomeParentOf(typeParameters);
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitFunctionExpression(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_typeParameters, visitor);
|
| - _safelyVisitChild(_parameters, visitor);
|
| - _safelyVisitChild(_body, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * The invocation of a function resulting from evaluating an expression.
|
| - * Invocations of methods and other forms of functions are represented by
|
| - * [MethodInvocation] nodes. Invocations of getters and setters are represented
|
| - * by either [PrefixedIdentifier] or [PropertyAccess] nodes.
|
| - *
|
| - * > functionExpressionInvoction ::=
|
| - * > [Expression] [TypeArgumentList]? [ArgumentList]
|
| - */
|
| -class FunctionExpressionInvocation extends Expression {
|
| - /**
|
| - * The expression producing the function being invoked.
|
| - */
|
| - Expression _function;
|
| -
|
| - /**
|
| - * The type arguments to be applied to the method being invoked, or `null` if
|
| - * no type arguments were provided.
|
| - */
|
| - TypeArgumentList _typeArguments;
|
| -
|
| - /**
|
| - * The list of arguments to the function.
|
| - */
|
| - ArgumentList _argumentList;
|
| -
|
| - /**
|
| - * The element associated with the function being invoked based on static type
|
| - * information, or `null` if the AST structure has not been resolved or the
|
| - * function could not be resolved.
|
| - */
|
| - ExecutableElement staticElement;
|
| -
|
| - /**
|
| - * The element associated with the function being invoked based on propagated
|
| - * type information, or `null` if the AST structure has not been resolved or
|
| - * the function could not be resolved.
|
| - */
|
| - ExecutableElement propagatedElement;
|
| -
|
| - /**
|
| - * Initialize a newly created function expression invocation.
|
| - */
|
| - FunctionExpressionInvocation(Expression function,
|
| - TypeArgumentList typeArguments, ArgumentList argumentList) {
|
| - _function = _becomeParentOf(function);
|
| - _typeArguments = _becomeParentOf(typeArguments);
|
| - _argumentList = _becomeParentOf(argumentList);
|
| - }
|
| -
|
| - /**
|
| - * Return the list of arguments to the method.
|
| - */
|
| - ArgumentList get argumentList => _argumentList;
|
| -
|
| - /**
|
| - * Set the list of arguments to the method to the given [argumentList].
|
| - */
|
| - void set argumentList(ArgumentList argumentList) {
|
| - _argumentList = _becomeParentOf(argumentList);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => _function.beginToken;
|
| -
|
| - /**
|
| - * Return the best element available for the function being invoked. If
|
| - * resolution was able to find a better element based on type propagation,
|
| - * that element will be returned. Otherwise, the element found using the
|
| - * result of static analysis will be returned. If resolution has not been
|
| - * performed, then `null` will be returned.
|
| - */
|
| - ExecutableElement get bestElement {
|
| - ExecutableElement element = propagatedElement;
|
| - if (element == null) {
|
| - element = staticElement;
|
| - }
|
| - return element;
|
| - }
|
| -
|
| - @override
|
| - Iterable get childEntities =>
|
| - new ChildEntities()..add(_function)..add(_argumentList);
|
| -
|
| - @override
|
| - Token get endToken => _argumentList.endToken;
|
| -
|
| - /**
|
| - * Return the expression producing the function being invoked.
|
| - */
|
| - Expression get function => _function;
|
| -
|
| - /**
|
| - * Set the expression producing the function being invoked to the given
|
| - * [expression].
|
| - */
|
| - void set function(Expression expression) {
|
| - _function = _becomeParentOf(expression);
|
| - }
|
| -
|
| - @override
|
| - int get precedence => 15;
|
| -
|
| - /**
|
| - * Return the type arguments to be applied to the method being invoked, or
|
| - * `null` if no type arguments were provided.
|
| - */
|
| - TypeArgumentList get typeArguments => _typeArguments;
|
| -
|
| - /**
|
| - * Set the type arguments to be applied to the method being invoked to the
|
| - * given [typeArguments].
|
| - */
|
| - void set typeArguments(TypeArgumentList typeArguments) {
|
| - _typeArguments = _becomeParentOf(typeArguments);
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitFunctionExpressionInvocation(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_function, visitor);
|
| - _safelyVisitChild(_typeArguments, visitor);
|
| - _safelyVisitChild(_argumentList, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A function type alias.
|
| - *
|
| - * > functionTypeAlias ::=
|
| - * > functionPrefix [TypeParameterList]? [FormalParameterList] ';'
|
| - * >
|
| - * > functionPrefix ::=
|
| - * > [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 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, name, semicolon) {
|
| - _returnType = _becomeParentOf(returnType);
|
| - _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 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);
|
| - }
|
| -
|
| - /**
|
| - * Return the name of the return type of the function type being defined, or
|
| - * `null` if no return type was given.
|
| - */
|
| - TypeName get returnType => _returnType;
|
| -
|
| - /**
|
| - * Set the name of the return type of the function type being defined to the
|
| - * given [typeName].
|
| - */
|
| - void set returnType(TypeName typeName) {
|
| - _returnType = _becomeParentOf(typeName);
|
| - }
|
| -
|
| - /**
|
| - * Return the type parameters for the function type, or `null` if the function
|
| - * type does not have any type parameters.
|
| - */
|
| - TypeParameterList get typeParameters => _typeParameters;
|
| -
|
| - /**
|
| - * Set the type parameters for the function type to the given list of
|
| - * [typeParameters].
|
| - */
|
| - void set typeParameters(TypeParameterList typeParameters) {
|
| - _typeParameters = _becomeParentOf(typeParameters);
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitFunctionTypeAlias(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - super.visitChildren(visitor);
|
| - _safelyVisitChild(_returnType, visitor);
|
| - _safelyVisitChild(_name, visitor);
|
| - _safelyVisitChild(_typeParameters, visitor);
|
| - _safelyVisitChild(_parameters, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A function-typed formal parameter.
|
| - *
|
| - * > functionSignature ::=
|
| - * > [TypeName]? [SimpleIdentifier] [TypeParameterList]? [FormalParameterList]
|
| - */
|
| -class FunctionTypedFormalParameter extends NormalFormalParameter {
|
| - /**
|
| - * The return type of the function, or `null` if the function does not have a
|
| - * return type.
|
| - */
|
| - TypeName _returnType;
|
| -
|
| - /**
|
| - * The type parameters associated with the function, or `null` if the function
|
| - * is not a generic function.
|
| - */
|
| - TypeParameterList _typeParameters;
|
| -
|
| - /**
|
| - * The parameters of the function-typed parameter.
|
| - */
|
| - FormalParameterList _parameters;
|
| -
|
| - /**
|
| - * Initialize a newly created formal parameter. Either or both of the
|
| - * [comment] and [metadata] can be `null` if the parameter does not have the
|
| - * corresponding attribute. The [returnType] can be `null` if no return type
|
| - * was specified.
|
| - */
|
| - FunctionTypedFormalParameter(Comment comment, List<Annotation> metadata,
|
| - TypeName returnType, SimpleIdentifier identifier,
|
| - TypeParameterList typeParameters, FormalParameterList parameters)
|
| - : super(comment, metadata, identifier) {
|
| - _returnType = _becomeParentOf(returnType);
|
| - _typeParameters = _becomeParentOf(typeParameters);
|
| - _parameters = _becomeParentOf(parameters);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken {
|
| - if (_returnType != null) {
|
| - return _returnType.beginToken;
|
| - }
|
| - return identifier.beginToken;
|
| - }
|
| -
|
| - @override
|
| - Iterable get childEntities =>
|
| - super._childEntities..add(_returnType)..add(identifier)..add(parameters);
|
| -
|
| - @override
|
| - Token get endToken => _parameters.endToken;
|
| -
|
| - @override
|
| - bool get isConst => false;
|
| -
|
| - @override
|
| - bool get isFinal => false;
|
| -
|
| - /**
|
| - * Return the parameters of the function-typed parameter.
|
| - */
|
| - FormalParameterList get parameters => _parameters;
|
| -
|
| - /**
|
| - * Set the parameters of the function-typed parameter to the given
|
| - * [parameters].
|
| - */
|
| - void set parameters(FormalParameterList parameters) {
|
| - _parameters = _becomeParentOf(parameters);
|
| - }
|
| -
|
| - /**
|
| - * Return the return type of the function, or `null` if the function does not
|
| - * have a return type.
|
| - */
|
| - TypeName get returnType => _returnType;
|
| -
|
| - /**
|
| - * Set the return type of the function to the given [type].
|
| - */
|
| - void set returnType(TypeName type) {
|
| - _returnType = _becomeParentOf(type);
|
| - }
|
| -
|
| - /**
|
| - * Return the type parameters associated with this function, or `null` if
|
| - * this function is not a generic function.
|
| - */
|
| - TypeParameterList get typeParameters => _typeParameters;
|
| -
|
| - /**
|
| - * Set the type parameters associated with this method to the given
|
| - * [typeParameters].
|
| - */
|
| - void set typeParameters(TypeParameterList typeParameters) {
|
| - _typeParameters = _becomeParentOf(typeParameters);
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitFunctionTypedFormalParameter(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - super.visitChildren(visitor);
|
| - _safelyVisitChild(_returnType, visitor);
|
| - _safelyVisitChild(identifier, visitor);
|
| - _safelyVisitChild(_typeParameters, visitor);
|
| - _safelyVisitChild(_parameters, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * An AST visitor that will recursively visit all of the nodes in an AST
|
| - * structure (like instances of the class [RecursiveAstVisitor]). In addition,
|
| - * when a node of a specific type is visited not only will the visit method for
|
| - * that specific type of node be invoked, but additional methods for the
|
| - * superclasses of that node will also be invoked. For example, using an
|
| - * instance of this class to visit a [Block] will cause the method [visitBlock]
|
| - * to be invoked but will also cause the methods [visitStatement] and
|
| - * [visitNode] to be subsequently invoked. This allows visitors to be written
|
| - * that visit all statements without needing to override the visit method for
|
| - * each of the specific subclasses of [Statement].
|
| - *
|
| - * Subclasses that override a visit method must either invoke the overridden
|
| - * visit method or explicitly invoke the more general visit method. Failure to
|
| - * do so will cause the visit methods for superclasses of the node to not be
|
| - * invoked and will cause the children of the visited node to not be visited.
|
| - */
|
| -class GeneralizingAstVisitor<R> implements AstVisitor<R> {
|
| - @override
|
| - R visitAdjacentStrings(AdjacentStrings node) => visitStringLiteral(node);
|
| -
|
| - R visitAnnotatedNode(AnnotatedNode node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitAnnotation(Annotation node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitArgumentList(ArgumentList node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitAsExpression(AsExpression node) => visitExpression(node);
|
| -
|
| - @override
|
| - R visitAssertStatement(AssertStatement node) => visitStatement(node);
|
| -
|
| - @override
|
| - R visitAssignmentExpression(AssignmentExpression node) =>
|
| - visitExpression(node);
|
| -
|
| - @override
|
| - R visitAwaitExpression(AwaitExpression node) => visitExpression(node);
|
| -
|
| - @override
|
| - R visitBinaryExpression(BinaryExpression node) => visitExpression(node);
|
| -
|
| - @override
|
| - R visitBlock(Block node) => visitStatement(node);
|
| -
|
| - @override
|
| - R visitBlockFunctionBody(BlockFunctionBody node) => visitFunctionBody(node);
|
| -
|
| - @override
|
| - R visitBooleanLiteral(BooleanLiteral node) => visitLiteral(node);
|
| -
|
| - @override
|
| - 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) =>
|
| - 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);
|
| -
|
| - @override
|
| - R visitCommentReference(CommentReference node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitCompilationUnit(CompilationUnit node) => visitNode(node);
|
| -
|
| - R visitCompilationUnitMember(CompilationUnitMember node) =>
|
| - visitDeclaration(node);
|
| -
|
| - @override
|
| - R visitConditionalExpression(ConditionalExpression node) =>
|
| - visitExpression(node);
|
| -
|
| - @override
|
| - R visitConstructorDeclaration(ConstructorDeclaration node) =>
|
| - visitClassMember(node);
|
| -
|
| - @override
|
| - R visitConstructorFieldInitializer(ConstructorFieldInitializer node) =>
|
| - visitConstructorInitializer(node);
|
| -
|
| - R visitConstructorInitializer(ConstructorInitializer node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitConstructorName(ConstructorName node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitContinueStatement(ContinueStatement node) => visitStatement(node);
|
| -
|
| - R visitDeclaration(Declaration node) => visitAnnotatedNode(node);
|
| -
|
| - @override
|
| - R visitDeclaredIdentifier(DeclaredIdentifier node) => visitDeclaration(node);
|
| -
|
| - @override
|
| - R visitDefaultFormalParameter(DefaultFormalParameter node) =>
|
| - visitFormalParameter(node);
|
| -
|
| - R visitDirective(Directive node) => visitAnnotatedNode(node);
|
| -
|
| - @override
|
| - R visitDoStatement(DoStatement node) => visitStatement(node);
|
| -
|
| - @override
|
| - R visitDoubleLiteral(DoubleLiteral node) => visitLiteral(node);
|
| -
|
| - @override
|
| - R visitEmptyFunctionBody(EmptyFunctionBody node) => visitFunctionBody(node);
|
| -
|
| - @override
|
| - R visitEmptyStatement(EmptyStatement node) => visitStatement(node);
|
| -
|
| - @override
|
| - R visitEnumConstantDeclaration(EnumConstantDeclaration node) =>
|
| - visitDeclaration(node);
|
| -
|
| - @override
|
| - R visitEnumDeclaration(EnumDeclaration node) =>
|
| - visitNamedCompilationUnitMember(node);
|
| -
|
| - @override
|
| - R visitExportDirective(ExportDirective node) => visitNamespaceDirective(node);
|
| -
|
| - R visitExpression(Expression node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitExpressionFunctionBody(ExpressionFunctionBody node) =>
|
| - visitFunctionBody(node);
|
| -
|
| - @override
|
| - R visitExpressionStatement(ExpressionStatement node) => visitStatement(node);
|
| -
|
| - @override
|
| - R visitExtendsClause(ExtendsClause node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitFieldDeclaration(FieldDeclaration node) => visitClassMember(node);
|
| -
|
| - @override
|
| - R visitFieldFormalParameter(FieldFormalParameter node) =>
|
| - visitNormalFormalParameter(node);
|
| -
|
| - @override
|
| - R visitForEachStatement(ForEachStatement node) => visitStatement(node);
|
| -
|
| - R visitFormalParameter(FormalParameter node) => visitNode(node);
|
| -
|
| - @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) =>
|
| - visitNamedCompilationUnitMember(node);
|
| -
|
| - @override
|
| - R visitFunctionDeclarationStatement(FunctionDeclarationStatement node) =>
|
| - visitStatement(node);
|
| -
|
| - @override
|
| - R visitFunctionExpression(FunctionExpression node) => visitExpression(node);
|
| -
|
| - @override
|
| - R visitFunctionExpressionInvocation(FunctionExpressionInvocation node) =>
|
| - visitExpression(node);
|
| -
|
| - @override
|
| - R visitFunctionTypeAlias(FunctionTypeAlias node) => visitTypeAlias(node);
|
| -
|
| - @override
|
| - R visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) =>
|
| - visitNormalFormalParameter(node);
|
| -
|
| - @override
|
| - R visitHideCombinator(HideCombinator node) => visitCombinator(node);
|
| -
|
| - R visitIdentifier(Identifier node) => visitExpression(node);
|
| -
|
| - @override
|
| - R visitIfStatement(IfStatement node) => visitStatement(node);
|
| -
|
| - @override
|
| - R visitImplementsClause(ImplementsClause node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitImportDirective(ImportDirective node) => visitNamespaceDirective(node);
|
| -
|
| - @override
|
| - R visitIndexExpression(IndexExpression node) => visitExpression(node);
|
| -
|
| - @override
|
| - R visitInstanceCreationExpression(InstanceCreationExpression node) =>
|
| - visitExpression(node);
|
| -
|
| - @override
|
| - R visitIntegerLiteral(IntegerLiteral node) => visitLiteral(node);
|
| -
|
| - R visitInterpolationElement(InterpolationElement node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitInterpolationExpression(InterpolationExpression node) =>
|
| - visitInterpolationElement(node);
|
| -
|
| - @override
|
| - R visitInterpolationString(InterpolationString node) =>
|
| - visitInterpolationElement(node);
|
| -
|
| - @override
|
| - R visitIsExpression(IsExpression node) => visitExpression(node);
|
| -
|
| - @override
|
| - R visitLabel(Label node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitLabeledStatement(LabeledStatement node) => visitStatement(node);
|
| -
|
| - @override
|
| - R visitLibraryDirective(LibraryDirective node) => visitDirective(node);
|
| -
|
| - @override
|
| - R visitLibraryIdentifier(LibraryIdentifier node) => visitIdentifier(node);
|
| -
|
| - @override
|
| - R visitListLiteral(ListLiteral node) => visitTypedLiteral(node);
|
| -
|
| - R visitLiteral(Literal node) => visitExpression(node);
|
| -
|
| - @override
|
| - R visitMapLiteral(MapLiteral node) => visitTypedLiteral(node);
|
| -
|
| - @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
|
| - R visitNativeFunctionBody(NativeFunctionBody node) => visitFunctionBody(node);
|
| -
|
| - R visitNode(AstNode node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - R visitNormalFormalParameter(NormalFormalParameter node) =>
|
| - visitFormalParameter(node);
|
| -
|
| - @override
|
| - R visitNullLiteral(NullLiteral node) => visitLiteral(node);
|
| -
|
| - @override
|
| - R visitParenthesizedExpression(ParenthesizedExpression node) =>
|
| - visitExpression(node);
|
| -
|
| - @override
|
| - R visitPartDirective(PartDirective node) => visitUriBasedDirective(node);
|
| -
|
| - @override
|
| - R visitPartOfDirective(PartOfDirective node) => visitDirective(node);
|
| -
|
| - @override
|
| - R visitPostfixExpression(PostfixExpression node) => visitExpression(node);
|
| -
|
| - @override
|
| - R visitPrefixedIdentifier(PrefixedIdentifier node) => visitIdentifier(node);
|
| -
|
| - @override
|
| - R visitPrefixExpression(PrefixExpression node) => visitExpression(node);
|
| -
|
| - @override
|
| - R visitPropertyAccess(PropertyAccess node) => visitExpression(node);
|
| -
|
| - @override
|
| - R visitRedirectingConstructorInvocation(
|
| - RedirectingConstructorInvocation node) =>
|
| - visitConstructorInitializer(node);
|
| -
|
| - @override
|
| - R visitRethrowExpression(RethrowExpression node) => visitExpression(node);
|
| -
|
| - @override
|
| - R visitReturnStatement(ReturnStatement node) => visitStatement(node);
|
| -
|
| - @override
|
| - R visitScriptTag(ScriptTag scriptTag) => visitNode(scriptTag);
|
| -
|
| - @override
|
| - R visitShowCombinator(ShowCombinator node) => visitCombinator(node);
|
| -
|
| - @override
|
| - R visitSimpleFormalParameter(SimpleFormalParameter node) =>
|
| - visitNormalFormalParameter(node);
|
| -
|
| - @override
|
| - R visitSimpleIdentifier(SimpleIdentifier node) => visitIdentifier(node);
|
| -
|
| - @override
|
| - R visitSimpleStringLiteral(SimpleStringLiteral node) =>
|
| - visitSingleStringLiteral(node);
|
| -
|
| - R visitSingleStringLiteral(SingleStringLiteral node) =>
|
| - visitStringLiteral(node);
|
| -
|
| - R visitStatement(Statement node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitStringInterpolation(StringInterpolation node) =>
|
| - visitSingleStringLiteral(node);
|
| -
|
| - R visitStringLiteral(StringLiteral node) => visitLiteral(node);
|
| -
|
| - @override
|
| - R visitSuperConstructorInvocation(SuperConstructorInvocation node) =>
|
| - visitConstructorInitializer(node);
|
| -
|
| - @override
|
| - R visitSuperExpression(SuperExpression node) => visitExpression(node);
|
| -
|
| - @override
|
| - R visitSwitchCase(SwitchCase node) => visitSwitchMember(node);
|
| -
|
| - @override
|
| - R visitSwitchDefault(SwitchDefault node) => visitSwitchMember(node);
|
| -
|
| - R visitSwitchMember(SwitchMember node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitSwitchStatement(SwitchStatement node) => visitStatement(node);
|
| -
|
| - @override
|
| - R visitSymbolLiteral(SymbolLiteral node) => visitLiteral(node);
|
| -
|
| - @override
|
| - R visitThisExpression(ThisExpression node) => visitExpression(node);
|
| -
|
| - @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) => visitNamedCompilationUnitMember(node);
|
| -
|
| - @override
|
| - R visitTypeArgumentList(TypeArgumentList node) => visitNode(node);
|
| -
|
| - R visitTypedLiteral(TypedLiteral node) => visitLiteral(node);
|
| -
|
| - @override
|
| - R visitTypeName(TypeName node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitTypeParameter(TypeParameter node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitTypeParameterList(TypeParameterList node) => visitNode(node);
|
| -
|
| - R visitUriBasedDirective(UriBasedDirective node) => visitDirective(node);
|
| -
|
| - @override
|
| - R visitVariableDeclaration(VariableDeclaration node) =>
|
| - visitDeclaration(node);
|
| -
|
| - @override
|
| - R visitVariableDeclarationList(VariableDeclarationList node) =>
|
| - visitNode(node);
|
| -
|
| - @override
|
| - R visitVariableDeclarationStatement(VariableDeclarationStatement node) =>
|
| - visitStatement(node);
|
| -
|
| - @override
|
| - R visitWhileStatement(WhileStatement node) => visitStatement(node);
|
| -
|
| - @override
|
| - R visitWithClause(WithClause node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitYieldStatement(YieldStatement node) => visitStatement(node);
|
| -}
|
| -
|
| -class GeneralizingAstVisitor_BreadthFirstVisitor
|
| - extends GeneralizingAstVisitor<Object> {
|
| - final BreadthFirstVisitor BreadthFirstVisitor_this;
|
| -
|
| - GeneralizingAstVisitor_BreadthFirstVisitor(this.BreadthFirstVisitor_this)
|
| - : super();
|
| -
|
| - @override
|
| - Object visitNode(AstNode node) {
|
| - BreadthFirstVisitor_this._queue.add(node);
|
| - return null;
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A combinator that restricts the names being imported to those that are not in
|
| - * a given list.
|
| - *
|
| - * > hideCombinator ::=
|
| - * > 'hide' [SimpleIdentifier] (',' [SimpleIdentifier])*
|
| - */
|
| -class HideCombinator extends Combinator {
|
| - /**
|
| - * The list of names from the library that are hidden by this combinator.
|
| - */
|
| - NodeList<SimpleIdentifier> _hiddenNames;
|
| -
|
| - /**
|
| - * Initialize a newly created import show combinator.
|
| - */
|
| - HideCombinator(Token keyword, List<SimpleIdentifier> hiddenNames)
|
| - : super(keyword) {
|
| - _hiddenNames = new NodeList<SimpleIdentifier>(this, hiddenNames);
|
| - }
|
| -
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()
|
| - ..add(keyword)
|
| - ..addAll(_hiddenNames);
|
| -
|
| - @override
|
| - Token get endToken => _hiddenNames.endToken;
|
| -
|
| - /**
|
| - * Return the list of names from the library that are hidden by this
|
| - * combinator.
|
| - */
|
| - NodeList<SimpleIdentifier> get hiddenNames => _hiddenNames;
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitHideCombinator(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _hiddenNames.accept(visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A node that represents an identifier.
|
| - *
|
| - * > identifier ::=
|
| - * > [SimpleIdentifier]
|
| - * > | [PrefixedIdentifier]
|
| - */
|
| -abstract class Identifier extends Expression {
|
| - /**
|
| - * Return the best element available for this operator. If resolution was able
|
| - * to find a better element based on type propagation, that element will be
|
| - * returned. Otherwise, the element found using the result of static analysis
|
| - * will be returned. If resolution has not been performed, then `null` will be
|
| - * returned.
|
| - */
|
| - Element get bestElement;
|
| -
|
| - @override
|
| - bool get isAssignable => true;
|
| -
|
| - /**
|
| - * Return the lexical representation of the identifier.
|
| - */
|
| - String get name;
|
| -
|
| - /**
|
| - * Return the element associated with this identifier based on propagated type
|
| - * information, or `null` if the AST structure has not been resolved or if
|
| - * this identifier could not be resolved. One example of the latter case is an
|
| - * identifier that is not defined within the scope in which it appears.
|
| - */
|
| - Element get propagatedElement;
|
| -
|
| - /**
|
| - * Return the element associated with this identifier based on static type
|
| - * information, or `null` if the AST structure has not been resolved or if
|
| - * this identifier could not be resolved. One example of the latter case is an
|
| - * identifier that is not defined within the scope in which it appears
|
| - */
|
| - Element get staticElement;
|
| -
|
| - /**
|
| - * Return `true` if the given [name] is visible only within the library in
|
| - * which it is declared.
|
| - */
|
| - static bool isPrivateName(String name) =>
|
| - StringUtilities.startsWithChar(name, 0x5F);
|
| -}
|
| -
|
| -/**
|
| - * An if statement.
|
| - *
|
| - * > ifStatement ::=
|
| - * > 'if' '(' [Expression] ')' [Statement] ('else' [Statement])?
|
| - */
|
| -class IfStatement extends Statement {
|
| - /**
|
| - * The token representing the 'if' keyword.
|
| - */
|
| - Token ifKeyword;
|
| -
|
| - /**
|
| - * The left parenthesis.
|
| - */
|
| - Token leftParenthesis;
|
| -
|
| - /**
|
| - * The condition used to determine which of the statements is executed next.
|
| - */
|
| - Expression _condition;
|
| -
|
| - /**
|
| - * The right parenthesis.
|
| - */
|
| - Token rightParenthesis;
|
| -
|
| - /**
|
| - * The statement that is executed if the condition evaluates to `true`.
|
| - */
|
| - Statement _thenStatement;
|
| -
|
| - /**
|
| - * The token representing the 'else' keyword, or `null` if there is no else
|
| - * statement.
|
| - */
|
| - Token elseKeyword;
|
| -
|
| - /**
|
| - * The statement that is executed if the condition evaluates to `false`, or
|
| - * `null` if there is no else statement.
|
| - */
|
| - Statement _elseStatement;
|
| -
|
| - /**
|
| - * Initialize a newly created if statement. The [elseKeyword] and
|
| - * [elseStatement] can be `null` if there is no else clause.
|
| - */
|
| - IfStatement(this.ifKeyword, this.leftParenthesis, Expression condition,
|
| - this.rightParenthesis, Statement thenStatement, this.elseKeyword,
|
| - Statement elseStatement) {
|
| - _condition = _becomeParentOf(condition);
|
| - _thenStatement = _becomeParentOf(thenStatement);
|
| - _elseStatement = _becomeParentOf(elseStatement);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => ifKeyword;
|
| -
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()
|
| - ..add(ifKeyword)
|
| - ..add(leftParenthesis)
|
| - ..add(_condition)
|
| - ..add(rightParenthesis)
|
| - ..add(_thenStatement)
|
| - ..add(elseKeyword)
|
| - ..add(_elseStatement);
|
| -
|
| - /**
|
| - * Return the condition used to determine which of the statements is executed
|
| - * next.
|
| - */
|
| - Expression get condition => _condition;
|
| -
|
| - /**
|
| - * Set the condition used to determine which of the statements is executed
|
| - * next to the given [expression].
|
| - */
|
| - void set condition(Expression expression) {
|
| - _condition = _becomeParentOf(expression);
|
| - }
|
| -
|
| - /**
|
| - * Return the statement that is executed if the condition evaluates to
|
| - * `false`, or `null` if there is no else statement.
|
| - */
|
| - Statement get elseStatement => _elseStatement;
|
| -
|
| - /**
|
| - * Set the statement that is executed if the condition evaluates to `false`
|
| - * to the given [statement].
|
| - */
|
| - void set elseStatement(Statement statement) {
|
| - _elseStatement = _becomeParentOf(statement);
|
| - }
|
| -
|
| - @override
|
| - Token get endToken {
|
| - if (_elseStatement != null) {
|
| - return _elseStatement.endToken;
|
| - }
|
| - return _thenStatement.endToken;
|
| - }
|
| -
|
| - /**
|
| - * Return the statement that is executed if the condition evaluates to `true`.
|
| - */
|
| - Statement get thenStatement => _thenStatement;
|
| -
|
| - /**
|
| - * Set the statement that is executed if the condition evaluates to `true` to
|
| - * the given [statement].
|
| - */
|
| - void set thenStatement(Statement statement) {
|
| - _thenStatement = _becomeParentOf(statement);
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitIfStatement(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_condition, visitor);
|
| - _safelyVisitChild(_thenStatement, visitor);
|
| - _safelyVisitChild(_elseStatement, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * The "implements" clause in an class declaration.
|
| - *
|
| - * > implementsClause ::=
|
| - * > 'implements' [TypeName] (',' [TypeName])*
|
| - */
|
| -class ImplementsClause extends AstNode {
|
| - /**
|
| - * The token representing the 'implements' keyword.
|
| - */
|
| - Token implementsKeyword;
|
| -
|
| - /**
|
| - * The interfaces that are being implemented.
|
| - */
|
| - NodeList<TypeName> _interfaces;
|
| -
|
| - /**
|
| - * Initialize a newly created implements clause.
|
| - */
|
| - ImplementsClause(this.implementsKeyword, List<TypeName> interfaces) {
|
| - _interfaces = new NodeList<TypeName>(this, interfaces);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => implementsKeyword;
|
| -
|
| - /**
|
| - * TODO(paulberry): add commas.
|
| - */
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()
|
| - ..add(implementsKeyword)
|
| - ..addAll(interfaces);
|
| -
|
| - @override
|
| - Token get endToken => _interfaces.endToken;
|
| -
|
| - /**
|
| - * Return the list of the interfaces that are being implemented.
|
| - */
|
| - NodeList<TypeName> get interfaces => _interfaces;
|
| -
|
| - /**
|
| - * Return the token representing the 'implements' keyword.
|
| - */
|
| - @deprecated // Use "this.implementsKeyword"
|
| - Token get keyword => implementsKeyword;
|
| -
|
| - /**
|
| - * Set the token representing the 'implements' keyword to the given [token].
|
| - */
|
| - @deprecated // Use "this.implementsKeyword"
|
| - set keyword(Token token) {
|
| - implementsKeyword = token;
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitImplementsClause(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _interfaces.accept(visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * An import directive.
|
| - *
|
| - * > importDirective ::=
|
| - * > [Annotation] 'import' [StringLiteral] ('as' identifier)? [Combinator]* ';'
|
| - * > | [Annotation] 'import' [StringLiteral] 'deferred' 'as' identifier [Combinator]* ';'
|
| - */
|
| -class ImportDirective extends NamespaceDirective {
|
| - static Comparator<ImportDirective> COMPARATOR = (ImportDirective import1,
|
| - ImportDirective import2) {
|
| - //
|
| - // uri
|
| - //
|
| - StringLiteral uri1 = import1.uri;
|
| - StringLiteral uri2 = import2.uri;
|
| - String uriStr1 = uri1.stringValue;
|
| - String uriStr2 = uri2.stringValue;
|
| - if (uriStr1 != null || uriStr2 != null) {
|
| - if (uriStr1 == null) {
|
| - return -1;
|
| - } else if (uriStr2 == null) {
|
| - return 1;
|
| - } else {
|
| - int compare = uriStr1.compareTo(uriStr2);
|
| - if (compare != 0) {
|
| - return compare;
|
| - }
|
| - }
|
| - }
|
| - //
|
| - // as
|
| - //
|
| - SimpleIdentifier prefix1 = import1.prefix;
|
| - SimpleIdentifier prefix2 = import2.prefix;
|
| - String prefixStr1 = prefix1 != null ? prefix1.name : null;
|
| - String prefixStr2 = prefix2 != null ? prefix2.name : null;
|
| - if (prefixStr1 != null || prefixStr2 != null) {
|
| - if (prefixStr1 == null) {
|
| - return -1;
|
| - } else if (prefixStr2 == null) {
|
| - return 1;
|
| - } else {
|
| - int compare = prefixStr1.compareTo(prefixStr2);
|
| - if (compare != 0) {
|
| - return compare;
|
| - }
|
| - }
|
| - }
|
| - //
|
| - // hides and shows
|
| - //
|
| - NodeList<Combinator> combinators1 = import1.combinators;
|
| - List<String> allHides1 = new List<String>();
|
| - List<String> allShows1 = new List<String>();
|
| - for (Combinator combinator in combinators1) {
|
| - if (combinator is HideCombinator) {
|
| - NodeList<SimpleIdentifier> hides = combinator.hiddenNames;
|
| - for (SimpleIdentifier simpleIdentifier in hides) {
|
| - allHides1.add(simpleIdentifier.name);
|
| - }
|
| - } else {
|
| - NodeList<SimpleIdentifier> shows =
|
| - (combinator as ShowCombinator).shownNames;
|
| - for (SimpleIdentifier simpleIdentifier in shows) {
|
| - allShows1.add(simpleIdentifier.name);
|
| - }
|
| - }
|
| - }
|
| - NodeList<Combinator> combinators2 = import2.combinators;
|
| - List<String> allHides2 = new List<String>();
|
| - List<String> allShows2 = new List<String>();
|
| - for (Combinator combinator in combinators2) {
|
| - if (combinator is HideCombinator) {
|
| - NodeList<SimpleIdentifier> hides = combinator.hiddenNames;
|
| - for (SimpleIdentifier simpleIdentifier in hides) {
|
| - allHides2.add(simpleIdentifier.name);
|
| - }
|
| - } else {
|
| - NodeList<SimpleIdentifier> shows =
|
| - (combinator as ShowCombinator).shownNames;
|
| - for (SimpleIdentifier simpleIdentifier in shows) {
|
| - allShows2.add(simpleIdentifier.name);
|
| - }
|
| - }
|
| - }
|
| - // test lengths of combinator lists first
|
| - if (allHides1.length != allHides2.length) {
|
| - return allHides1.length - allHides2.length;
|
| - }
|
| - if (allShows1.length != allShows2.length) {
|
| - return allShows1.length - allShows2.length;
|
| - }
|
| - // next ensure that the lists are equivalent
|
| - if (!javaCollectionContainsAll(allHides1, allHides2)) {
|
| - return -1;
|
| - }
|
| - if (!javaCollectionContainsAll(allShows1, allShows2)) {
|
| - return -1;
|
| - }
|
| - return 0;
|
| - };
|
| -
|
| - /**
|
| - * The token representing the 'deferred' keyword, or `null` if the imported is
|
| - * not deferred.
|
| - */
|
| - Token deferredKeyword;
|
| -
|
| - /**
|
| - * The token representing the 'as' keyword, or `null` if the imported names are
|
| - * not prefixed.
|
| - */
|
| - Token asKeyword;
|
| -
|
| - /**
|
| - * The prefix to be used with the imported names, or `null` if the imported
|
| - * names are not prefixed.
|
| - */
|
| - SimpleIdentifier _prefix;
|
| -
|
| - /**
|
| - * Initialize a newly created import directive. Either or both of the
|
| - * [comment] and [metadata] can be `null` if the function does not have the
|
| - * corresponding attribute. The [deferredKeyword] can be `null` if the import
|
| - * is not deferred. The [asKeyword] and [prefix] can be `null` if the import
|
| - * does not specify a prefix. The list of [combinators] can be `null` if there
|
| - * are no combinators.
|
| - */
|
| - ImportDirective(Comment comment, List<Annotation> metadata, Token keyword,
|
| - StringLiteral libraryUri, this.deferredKeyword, this.asKeyword,
|
| - SimpleIdentifier prefix, List<Combinator> combinators, Token semicolon)
|
| - : super(comment, metadata, keyword, libraryUri, combinators, semicolon) {
|
| - _prefix = _becomeParentOf(prefix);
|
| - }
|
| -
|
| - /**
|
| - * The token representing the 'as' token, or `null` if the imported names are
|
| - * not prefixed.
|
| - */
|
| - @deprecated // Use "this.asKeyword"
|
| - Token get asToken => asKeyword;
|
| -
|
| - /**
|
| - * The token representing the 'as' token to the given token.
|
| - */
|
| - @deprecated // Use "this.asKeyword"
|
| - set asToken(Token token) {
|
| - asKeyword = token;
|
| - }
|
| -
|
| - @override
|
| - Iterable get childEntities => super._childEntities
|
| - ..add(_uri)
|
| - ..add(deferredKeyword)
|
| - ..add(asKeyword)
|
| - ..add(_prefix)
|
| - ..addAll(combinators)
|
| - ..add(semicolon);
|
| -
|
| - /**
|
| - * Return the token representing the 'deferred' token, or `null` if the
|
| - * imported is not deferred.
|
| - */
|
| - @deprecated // Use "this.deferredKeyword"
|
| - Token get deferredToken => deferredKeyword;
|
| -
|
| - /**
|
| - * Set the token representing the 'deferred' token to the given token.
|
| - */
|
| - @deprecated // Use "this.deferredKeyword"
|
| - set deferredToken(Token token) {
|
| - deferredKeyword = token;
|
| - }
|
| -
|
| - @override
|
| - ImportElement get element => super.element as ImportElement;
|
| -
|
| - /**
|
| - * Return the prefix to be used with the imported names, or `null` if the
|
| - * imported names are not prefixed.
|
| - */
|
| - SimpleIdentifier get prefix => _prefix;
|
| -
|
| - /**
|
| - * Set the prefix to be used with the imported names to the given [identifier].
|
| - */
|
| - void set prefix(SimpleIdentifier identifier) {
|
| - _prefix = _becomeParentOf(identifier);
|
| - }
|
| -
|
| - @override
|
| - LibraryElement get uriElement {
|
| - ImportElement element = this.element;
|
| - if (element == null) {
|
| - return null;
|
| - }
|
| - return element.importedLibrary;
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitImportDirective(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - super.visitChildren(visitor);
|
| - _safelyVisitChild(_prefix, visitor);
|
| - combinators.accept(visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * An object that will clone any AST structure that it visits. The cloner will
|
| - * clone the structure, replacing the specified ASTNode with a new ASTNode,
|
| - * mapping the old token stream to a new token stream, and preserving resolution
|
| - * results.
|
| - */
|
| -class IncrementalAstCloner implements AstVisitor<AstNode> {
|
| - /**
|
| - * The node to be replaced during the cloning process.
|
| - */
|
| - final AstNode _oldNode;
|
| -
|
| - /**
|
| - * The replacement node used during the cloning process.
|
| - */
|
| - final AstNode _newNode;
|
| -
|
| - /**
|
| - * A mapping of old tokens to new tokens used during the cloning process.
|
| - */
|
| - final TokenMap _tokenMap;
|
| -
|
| - /**
|
| - * Construct a new instance that will replace the [oldNode] with the [newNode]
|
| - * in the process of cloning an existing AST structure. The [tokenMap] is a
|
| - * mapping of old tokens to new tokens.
|
| - */
|
| - IncrementalAstCloner(this._oldNode, this._newNode, this._tokenMap);
|
| -
|
| - @override
|
| - AdjacentStrings visitAdjacentStrings(AdjacentStrings node) =>
|
| - new AdjacentStrings(_cloneNodeList(node.strings));
|
| -
|
| - @override
|
| - Annotation visitAnnotation(Annotation node) {
|
| - Annotation copy = new Annotation(_mapToken(node.atSign),
|
| - _cloneNode(node.name), _mapToken(node.period),
|
| - _cloneNode(node.constructorName), _cloneNode(node.arguments));
|
| - copy.element = node.element;
|
| - return copy;
|
| - }
|
| -
|
| - @override
|
| - ArgumentList visitArgumentList(ArgumentList node) => new ArgumentList(
|
| - _mapToken(node.leftParenthesis), _cloneNodeList(node.arguments),
|
| - _mapToken(node.rightParenthesis));
|
| -
|
| - @override
|
| - AsExpression visitAsExpression(AsExpression node) {
|
| - AsExpression copy = new AsExpression(_cloneNode(node.expression),
|
| - _mapToken(node.asOperator), _cloneNode(node.type));
|
| - copy.propagatedType = node.propagatedType;
|
| - copy.staticType = node.staticType;
|
| - return copy;
|
| - }
|
| -
|
| - @override
|
| - AstNode visitAssertStatement(AssertStatement node) => new AssertStatement(
|
| - _mapToken(node.assertKeyword), _mapToken(node.leftParenthesis),
|
| - _cloneNode(node.condition), _mapToken(node.rightParenthesis),
|
| - _mapToken(node.semicolon));
|
| -
|
| - @override
|
| - AssignmentExpression visitAssignmentExpression(AssignmentExpression node) {
|
| - AssignmentExpression copy = new AssignmentExpression(
|
| - _cloneNode(node.leftHandSide), _mapToken(node.operator),
|
| - _cloneNode(node.rightHandSide));
|
| - copy.propagatedElement = node.propagatedElement;
|
| - copy.propagatedType = node.propagatedType;
|
| - copy.staticElement = node.staticElement;
|
| - copy.staticType = node.staticType;
|
| - return copy;
|
| - }
|
| -
|
| - @override
|
| - AwaitExpression visitAwaitExpression(AwaitExpression node) =>
|
| - new AwaitExpression(
|
| - _mapToken(node.awaitKeyword), _cloneNode(node.expression));
|
| -
|
| - @override
|
| - BinaryExpression visitBinaryExpression(BinaryExpression node) {
|
| - BinaryExpression copy = new BinaryExpression(_cloneNode(node.leftOperand),
|
| - _mapToken(node.operator), _cloneNode(node.rightOperand));
|
| - copy.propagatedElement = node.propagatedElement;
|
| - copy.propagatedType = node.propagatedType;
|
| - copy.staticElement = node.staticElement;
|
| - copy.staticType = node.staticType;
|
| - return copy;
|
| - }
|
| -
|
| - @override
|
| - Block visitBlock(Block node) => new Block(_mapToken(node.leftBracket),
|
| - _cloneNodeList(node.statements), _mapToken(node.rightBracket));
|
| -
|
| - @override
|
| - BlockFunctionBody visitBlockFunctionBody(
|
| - BlockFunctionBody node) => new BlockFunctionBody(
|
| - _mapToken(node.keyword), _mapToken(node.star), _cloneNode(node.block));
|
| -
|
| - @override
|
| - BooleanLiteral visitBooleanLiteral(BooleanLiteral node) {
|
| - BooleanLiteral copy =
|
| - new BooleanLiteral(_mapToken(node.literal), node.value);
|
| - copy.propagatedType = node.propagatedType;
|
| - copy.staticType = node.staticType;
|
| - return copy;
|
| - }
|
| -
|
| - @override
|
| - BreakStatement visitBreakStatement(BreakStatement node) => new BreakStatement(
|
| - _mapToken(node.breakKeyword), _cloneNode(node.label),
|
| - _mapToken(node.semicolon));
|
| -
|
| - @override
|
| - CascadeExpression visitCascadeExpression(CascadeExpression node) {
|
| - CascadeExpression copy = new CascadeExpression(
|
| - _cloneNode(node.target), _cloneNodeList(node.cascadeSections));
|
| - copy.propagatedType = node.propagatedType;
|
| - copy.staticType = node.staticType;
|
| - return copy;
|
| - }
|
| -
|
| - @override
|
| - CatchClause visitCatchClause(CatchClause node) => new CatchClause(
|
| - _mapToken(node.onKeyword), _cloneNode(node.exceptionType),
|
| - _mapToken(node.catchKeyword), _mapToken(node.leftParenthesis),
|
| - _cloneNode(node.exceptionParameter), _mapToken(node.comma),
|
| - _cloneNode(node.stackTraceParameter), _mapToken(node.rightParenthesis),
|
| - _cloneNode(node.body));
|
| -
|
| - @override
|
| - ClassDeclaration visitClassDeclaration(ClassDeclaration node) {
|
| - ClassDeclaration copy = new ClassDeclaration(
|
| - _cloneNode(node.documentationComment), _cloneNodeList(node.metadata),
|
| - _mapToken(node.abstractKeyword), _mapToken(node.classKeyword),
|
| - _cloneNode(node.name), _cloneNode(node.typeParameters),
|
| - _cloneNode(node.extendsClause), _cloneNode(node.withClause),
|
| - _cloneNode(node.implementsClause), _mapToken(node.leftBracket),
|
| - _cloneNodeList(node.members), _mapToken(node.rightBracket));
|
| - copy.nativeClause = _cloneNode(node.nativeClause);
|
| - return copy;
|
| - }
|
| -
|
| - @override
|
| - ClassTypeAlias visitClassTypeAlias(ClassTypeAlias node) => new ClassTypeAlias(
|
| - _cloneNode(node.documentationComment), _cloneNodeList(node.metadata),
|
| - _mapToken(node.typedefKeyword), _cloneNode(node.name),
|
| - _cloneNode(node.typeParameters), _mapToken(node.equals),
|
| - _mapToken(node.abstractKeyword), _cloneNode(node.superclass),
|
| - _cloneNode(node.withClause), _cloneNode(node.implementsClause),
|
| - _mapToken(node.semicolon));
|
| -
|
| - @override
|
| - Comment visitComment(Comment node) {
|
| - if (node.isDocumentation) {
|
| - return Comment.createDocumentationCommentWithReferences(
|
| - _mapTokens(node.tokens), _cloneNodeList(node.references));
|
| - } else if (node.isBlock) {
|
| - return Comment.createBlockComment(_mapTokens(node.tokens));
|
| - }
|
| - return Comment.createEndOfLineComment(_mapTokens(node.tokens));
|
| - }
|
| -
|
| - @override
|
| - CommentReference visitCommentReference(CommentReference node) =>
|
| - new CommentReference(
|
| - _mapToken(node.newKeyword), _cloneNode(node.identifier));
|
| -
|
| - @override
|
| - CompilationUnit visitCompilationUnit(CompilationUnit node) {
|
| - CompilationUnit copy = new CompilationUnit(_mapToken(node.beginToken),
|
| - _cloneNode(node.scriptTag), _cloneNodeList(node.directives),
|
| - _cloneNodeList(node.declarations), _mapToken(node.endToken));
|
| - copy.lineInfo = node.lineInfo;
|
| - copy.element = node.element;
|
| - return copy;
|
| - }
|
| -
|
| - @override
|
| - ConditionalExpression visitConditionalExpression(ConditionalExpression node) {
|
| - ConditionalExpression copy = new ConditionalExpression(
|
| - _cloneNode(node.condition), _mapToken(node.question),
|
| - _cloneNode(node.thenExpression), _mapToken(node.colon),
|
| - _cloneNode(node.elseExpression));
|
| - copy.propagatedType = node.propagatedType;
|
| - copy.staticType = node.staticType;
|
| - return copy;
|
| - }
|
| -
|
| - @override
|
| - ConstructorDeclaration visitConstructorDeclaration(
|
| - ConstructorDeclaration node) {
|
| - ConstructorDeclaration copy = new ConstructorDeclaration(
|
| - _cloneNode(node.documentationComment), _cloneNodeList(node.metadata),
|
| - _mapToken(node.externalKeyword), _mapToken(node.constKeyword),
|
| - _mapToken(node.factoryKeyword), _cloneNode(node.returnType),
|
| - _mapToken(node.period), _cloneNode(node.name),
|
| - _cloneNode(node.parameters), _mapToken(node.separator),
|
| - _cloneNodeList(node.initializers),
|
| - _cloneNode(node.redirectedConstructor), _cloneNode(node.body));
|
| - copy.element = node.element;
|
| - return copy;
|
| - }
|
| -
|
| - @override
|
| - ConstructorFieldInitializer visitConstructorFieldInitializer(
|
| - ConstructorFieldInitializer node) => new ConstructorFieldInitializer(
|
| - _mapToken(node.thisKeyword), _mapToken(node.period),
|
| - _cloneNode(node.fieldName), _mapToken(node.equals),
|
| - _cloneNode(node.expression));
|
| -
|
| - @override
|
| - ConstructorName visitConstructorName(ConstructorName node) {
|
| - ConstructorName copy = new ConstructorName(
|
| - _cloneNode(node.type), _mapToken(node.period), _cloneNode(node.name));
|
| - copy.staticElement = node.staticElement;
|
| - return copy;
|
| - }
|
| -
|
| - @override
|
| - ContinueStatement visitContinueStatement(ContinueStatement node) =>
|
| - new ContinueStatement(_mapToken(node.continueKeyword),
|
| - _cloneNode(node.label), _mapToken(node.semicolon));
|
| -
|
| - @override
|
| - DeclaredIdentifier visitDeclaredIdentifier(DeclaredIdentifier node) =>
|
| - new DeclaredIdentifier(_cloneNode(node.documentationComment),
|
| - _cloneNodeList(node.metadata), _mapToken(node.keyword),
|
| - _cloneNode(node.type), _cloneNode(node.identifier));
|
| -
|
| - @override
|
| - DefaultFormalParameter visitDefaultFormalParameter(
|
| - DefaultFormalParameter node) => new DefaultFormalParameter(
|
| - _cloneNode(node.parameter), node.kind, _mapToken(node.separator),
|
| - _cloneNode(node.defaultValue));
|
| -
|
| - @override
|
| - DoStatement visitDoStatement(DoStatement node) => new DoStatement(
|
| - _mapToken(node.doKeyword), _cloneNode(node.body),
|
| - _mapToken(node.whileKeyword), _mapToken(node.leftParenthesis),
|
| - _cloneNode(node.condition), _mapToken(node.rightParenthesis),
|
| - _mapToken(node.semicolon));
|
| -
|
| - @override
|
| - DoubleLiteral visitDoubleLiteral(DoubleLiteral node) {
|
| - DoubleLiteral copy = new DoubleLiteral(_mapToken(node.literal), node.value);
|
| - copy.propagatedType = node.propagatedType;
|
| - copy.staticType = node.staticType;
|
| - return copy;
|
| - }
|
| -
|
| - @override
|
| - EmptyFunctionBody visitEmptyFunctionBody(EmptyFunctionBody node) =>
|
| - new EmptyFunctionBody(_mapToken(node.semicolon));
|
| -
|
| - @override
|
| - EmptyStatement visitEmptyStatement(EmptyStatement node) =>
|
| - new EmptyStatement(_mapToken(node.semicolon));
|
| -
|
| - @override
|
| - AstNode visitEnumConstantDeclaration(EnumConstantDeclaration node) =>
|
| - new EnumConstantDeclaration(_cloneNode(node.documentationComment),
|
| - _cloneNodeList(node.metadata), _cloneNode(node.name));
|
| -
|
| - @override
|
| - AstNode visitEnumDeclaration(EnumDeclaration node) => new EnumDeclaration(
|
| - _cloneNode(node.documentationComment), _cloneNodeList(node.metadata),
|
| - _mapToken(node.enumKeyword), _cloneNode(node.name),
|
| - _mapToken(node.leftBracket), _cloneNodeList(node.constants),
|
| - _mapToken(node.rightBracket));
|
| -
|
| - @override
|
| - ExportDirective visitExportDirective(ExportDirective node) {
|
| - ExportDirective copy = new ExportDirective(
|
| - _cloneNode(node.documentationComment), _cloneNodeList(node.metadata),
|
| - _mapToken(node.keyword), _cloneNode(node.uri),
|
| - _cloneNodeList(node.combinators), _mapToken(node.semicolon));
|
| - copy.element = node.element;
|
| - return copy;
|
| - }
|
| -
|
| - @override
|
| - ExpressionFunctionBody visitExpressionFunctionBody(
|
| - ExpressionFunctionBody node) => new ExpressionFunctionBody(
|
| - _mapToken(node.keyword), _mapToken(node.functionDefinition),
|
| - _cloneNode(node.expression), _mapToken(node.semicolon));
|
| -
|
| - @override
|
| - ExpressionStatement visitExpressionStatement(ExpressionStatement node) =>
|
| - new ExpressionStatement(
|
| - _cloneNode(node.expression), _mapToken(node.semicolon));
|
| -
|
| - @override
|
| - ExtendsClause visitExtendsClause(ExtendsClause node) => new ExtendsClause(
|
| - _mapToken(node.extendsKeyword), _cloneNode(node.superclass));
|
| -
|
| - @override
|
| - FieldDeclaration visitFieldDeclaration(FieldDeclaration node) =>
|
| - new FieldDeclaration(_cloneNode(node.documentationComment),
|
| - _cloneNodeList(node.metadata), _mapToken(node.staticKeyword),
|
| - _cloneNode(node.fields), _mapToken(node.semicolon));
|
| -
|
| - @override
|
| - FieldFormalParameter visitFieldFormalParameter(FieldFormalParameter node) =>
|
| - new FieldFormalParameter(_cloneNode(node.documentationComment),
|
| - _cloneNodeList(node.metadata), _mapToken(node.keyword),
|
| - _cloneNode(node.type), _mapToken(node.thisKeyword),
|
| - _mapToken(node.period), _cloneNode(node.identifier),
|
| - _cloneNode(node.typeParameters), _cloneNode(node.parameters));
|
| -
|
| - @override
|
| - ForEachStatement visitForEachStatement(ForEachStatement node) {
|
| - DeclaredIdentifier loopVariable = node.loopVariable;
|
| - if (loopVariable == null) {
|
| - return new ForEachStatement.withReference(_mapToken(node.awaitKeyword),
|
| - _mapToken(node.forKeyword), _mapToken(node.leftParenthesis),
|
| - _cloneNode(node.identifier), _mapToken(node.inKeyword),
|
| - _cloneNode(node.iterable), _mapToken(node.rightParenthesis),
|
| - _cloneNode(node.body));
|
| - }
|
| - return new ForEachStatement.withDeclaration(_mapToken(node.awaitKeyword),
|
| - _mapToken(node.forKeyword), _mapToken(node.leftParenthesis),
|
| - _cloneNode(loopVariable), _mapToken(node.inKeyword),
|
| - _cloneNode(node.iterable), _mapToken(node.rightParenthesis),
|
| - _cloneNode(node.body));
|
| - }
|
| -
|
| - @override
|
| - FormalParameterList visitFormalParameterList(FormalParameterList node) =>
|
| - new FormalParameterList(_mapToken(node.leftParenthesis),
|
| - _cloneNodeList(node.parameters), _mapToken(node.leftDelimiter),
|
| - _mapToken(node.rightDelimiter), _mapToken(node.rightParenthesis));
|
| -
|
| - @override
|
| - ForStatement visitForStatement(ForStatement node) => new ForStatement(
|
| - _mapToken(node.forKeyword), _mapToken(node.leftParenthesis),
|
| - _cloneNode(node.variables), _cloneNode(node.initialization),
|
| - _mapToken(node.leftSeparator), _cloneNode(node.condition),
|
| - _mapToken(node.rightSeparator), _cloneNodeList(node.updaters),
|
| - _mapToken(node.rightParenthesis), _cloneNode(node.body));
|
| -
|
| - @override
|
| - FunctionDeclaration visitFunctionDeclaration(FunctionDeclaration node) =>
|
| - new FunctionDeclaration(_cloneNode(node.documentationComment),
|
| - _cloneNodeList(node.metadata), _mapToken(node.externalKeyword),
|
| - _cloneNode(node.returnType), _mapToken(node.propertyKeyword),
|
| - _cloneNode(node.name), _cloneNode(node.functionExpression));
|
| -
|
| - @override
|
| - FunctionDeclarationStatement visitFunctionDeclarationStatement(
|
| - FunctionDeclarationStatement node) =>
|
| - new FunctionDeclarationStatement(_cloneNode(node.functionDeclaration));
|
| -
|
| - @override
|
| - FunctionExpression visitFunctionExpression(FunctionExpression node) {
|
| - FunctionExpression copy = new FunctionExpression(
|
| - _cloneNode(node.typeParameters), _cloneNode(node.parameters),
|
| - _cloneNode(node.body));
|
| - copy.element = node.element;
|
| - copy.propagatedType = node.propagatedType;
|
| - copy.staticType = node.staticType;
|
| - return copy;
|
| - }
|
| -
|
| - @override
|
| - FunctionExpressionInvocation visitFunctionExpressionInvocation(
|
| - FunctionExpressionInvocation node) {
|
| - FunctionExpressionInvocation copy = new FunctionExpressionInvocation(
|
| - _cloneNode(node.function), _cloneNode(node.typeArguments),
|
| - _cloneNode(node.argumentList));
|
| - copy.propagatedElement = node.propagatedElement;
|
| - copy.propagatedType = node.propagatedType;
|
| - copy.staticElement = node.staticElement;
|
| - copy.staticType = node.staticType;
|
| - return copy;
|
| - }
|
| -
|
| - @override
|
| - FunctionTypeAlias visitFunctionTypeAlias(FunctionTypeAlias node) =>
|
| - new FunctionTypeAlias(_cloneNode(node.documentationComment),
|
| - _cloneNodeList(node.metadata), _mapToken(node.typedefKeyword),
|
| - _cloneNode(node.returnType), _cloneNode(node.name),
|
| - _cloneNode(node.typeParameters), _cloneNode(node.parameters),
|
| - _mapToken(node.semicolon));
|
| -
|
| - @override
|
| - FunctionTypedFormalParameter visitFunctionTypedFormalParameter(
|
| - FunctionTypedFormalParameter node) => new FunctionTypedFormalParameter(
|
| - _cloneNode(node.documentationComment), _cloneNodeList(node.metadata),
|
| - _cloneNode(node.returnType), _cloneNode(node.identifier),
|
| - _cloneNode(node.typeParameters), _cloneNode(node.parameters));
|
| -
|
| - @override
|
| - HideCombinator visitHideCombinator(HideCombinator node) => new HideCombinator(
|
| - _mapToken(node.keyword), _cloneNodeList(node.hiddenNames));
|
| -
|
| - @override
|
| - IfStatement visitIfStatement(IfStatement node) => new IfStatement(
|
| - _mapToken(node.ifKeyword), _mapToken(node.leftParenthesis),
|
| - _cloneNode(node.condition), _mapToken(node.rightParenthesis),
|
| - _cloneNode(node.thenStatement), _mapToken(node.elseKeyword),
|
| - _cloneNode(node.elseStatement));
|
| -
|
| - @override
|
| - ImplementsClause visitImplementsClause(ImplementsClause node) =>
|
| - new ImplementsClause(
|
| - _mapToken(node.implementsKeyword), _cloneNodeList(node.interfaces));
|
| -
|
| - @override
|
| - ImportDirective visitImportDirective(ImportDirective node) =>
|
| - new ImportDirective(_cloneNode(node.documentationComment),
|
| - _cloneNodeList(node.metadata), _mapToken(node.keyword),
|
| - _cloneNode(node.uri), _mapToken(node.deferredKeyword),
|
| - _mapToken(node.asKeyword), _cloneNode(node.prefix),
|
| - _cloneNodeList(node.combinators), _mapToken(node.semicolon));
|
| -
|
| - @override
|
| - IndexExpression visitIndexExpression(IndexExpression node) {
|
| - Token period = _mapToken(node.period);
|
| - IndexExpression copy;
|
| - if (period == null) {
|
| - copy = new IndexExpression.forTarget(_cloneNode(node.target),
|
| - _mapToken(node.leftBracket), _cloneNode(node.index),
|
| - _mapToken(node.rightBracket));
|
| - } else {
|
| - copy = new IndexExpression.forCascade(period, _mapToken(node.leftBracket),
|
| - _cloneNode(node.index), _mapToken(node.rightBracket));
|
| - }
|
| - copy.auxiliaryElements = node.auxiliaryElements;
|
| - copy.propagatedElement = node.propagatedElement;
|
| - copy.propagatedType = node.propagatedType;
|
| - copy.staticElement = node.staticElement;
|
| - copy.staticType = node.staticType;
|
| - return copy;
|
| - }
|
| -
|
| - @override
|
| - InstanceCreationExpression visitInstanceCreationExpression(
|
| - InstanceCreationExpression node) {
|
| - InstanceCreationExpression copy = new InstanceCreationExpression(
|
| - _mapToken(node.keyword), _cloneNode(node.constructorName),
|
| - _cloneNode(node.argumentList));
|
| - copy.propagatedType = node.propagatedType;
|
| - copy.staticElement = node.staticElement;
|
| - copy.staticType = node.staticType;
|
| - return copy;
|
| - }
|
| -
|
| - @override
|
| - IntegerLiteral visitIntegerLiteral(IntegerLiteral node) {
|
| - IntegerLiteral copy =
|
| - new IntegerLiteral(_mapToken(node.literal), node.value);
|
| - copy.propagatedType = node.propagatedType;
|
| - copy.staticType = node.staticType;
|
| - return copy;
|
| - }
|
| -
|
| - @override
|
| - InterpolationExpression visitInterpolationExpression(
|
| - InterpolationExpression node) => new InterpolationExpression(
|
| - _mapToken(node.leftBracket), _cloneNode(node.expression),
|
| - _mapToken(node.rightBracket));
|
| -
|
| - @override
|
| - InterpolationString visitInterpolationString(InterpolationString node) =>
|
| - new InterpolationString(_mapToken(node.contents), node.value);
|
| -
|
| - @override
|
| - IsExpression visitIsExpression(IsExpression node) {
|
| - IsExpression copy = new IsExpression(_cloneNode(node.expression),
|
| - _mapToken(node.isOperator), _mapToken(node.notOperator),
|
| - _cloneNode(node.type));
|
| - copy.propagatedType = node.propagatedType;
|
| - copy.staticType = node.staticType;
|
| - return copy;
|
| - }
|
| -
|
| - @override
|
| - Label visitLabel(Label node) =>
|
| - new Label(_cloneNode(node.label), _mapToken(node.colon));
|
| -
|
| - @override
|
| - LabeledStatement visitLabeledStatement(LabeledStatement node) =>
|
| - new LabeledStatement(
|
| - _cloneNodeList(node.labels), _cloneNode(node.statement));
|
| -
|
| - @override
|
| - LibraryDirective visitLibraryDirective(LibraryDirective node) =>
|
| - new LibraryDirective(_cloneNode(node.documentationComment),
|
| - _cloneNodeList(node.metadata), _mapToken(node.libraryKeyword),
|
| - _cloneNode(node.name), _mapToken(node.semicolon));
|
| -
|
| - @override
|
| - LibraryIdentifier visitLibraryIdentifier(LibraryIdentifier node) {
|
| - LibraryIdentifier copy =
|
| - new LibraryIdentifier(_cloneNodeList(node.components));
|
| - copy.propagatedType = node.propagatedType;
|
| - copy.staticType = node.staticType;
|
| - return copy;
|
| - }
|
| -
|
| - @override
|
| - ListLiteral visitListLiteral(ListLiteral node) {
|
| - ListLiteral copy = new ListLiteral(_mapToken(node.constKeyword),
|
| - _cloneNode(node.typeArguments), _mapToken(node.leftBracket),
|
| - _cloneNodeList(node.elements), _mapToken(node.rightBracket));
|
| - copy.propagatedType = node.propagatedType;
|
| - copy.staticType = node.staticType;
|
| - return copy;
|
| - }
|
| -
|
| - @override
|
| - MapLiteral visitMapLiteral(MapLiteral node) {
|
| - MapLiteral copy = new MapLiteral(_mapToken(node.constKeyword),
|
| - _cloneNode(node.typeArguments), _mapToken(node.leftBracket),
|
| - _cloneNodeList(node.entries), _mapToken(node.rightBracket));
|
| - copy.propagatedType = node.propagatedType;
|
| - copy.staticType = node.staticType;
|
| - return copy;
|
| - }
|
| -
|
| - @override
|
| - MapLiteralEntry visitMapLiteralEntry(
|
| - MapLiteralEntry node) => new MapLiteralEntry(
|
| - _cloneNode(node.key), _mapToken(node.separator), _cloneNode(node.value));
|
| -
|
| - @override
|
| - MethodDeclaration visitMethodDeclaration(MethodDeclaration node) =>
|
| - new MethodDeclaration(_cloneNode(node.documentationComment),
|
| - _cloneNodeList(node.metadata), _mapToken(node.externalKeyword),
|
| - _mapToken(node.modifierKeyword), _cloneNode(node.returnType),
|
| - _mapToken(node.propertyKeyword), _mapToken(node.operatorKeyword),
|
| - _cloneNode(node.name), _cloneNode(node._typeParameters),
|
| - _cloneNode(node.parameters), _cloneNode(node.body));
|
| -
|
| - @override
|
| - MethodInvocation visitMethodInvocation(MethodInvocation node) {
|
| - MethodInvocation copy = new MethodInvocation(_cloneNode(node.target),
|
| - _mapToken(node.operator), _cloneNode(node.methodName),
|
| - _cloneNode(node.typeArguments), _cloneNode(node.argumentList));
|
| - copy.propagatedType = node.propagatedType;
|
| - copy.staticType = node.staticType;
|
| - return copy;
|
| - }
|
| -
|
| - @override
|
| - NamedExpression visitNamedExpression(NamedExpression node) {
|
| - NamedExpression copy =
|
| - new NamedExpression(_cloneNode(node.name), _cloneNode(node.expression));
|
| - copy.propagatedType = node.propagatedType;
|
| - copy.staticType = node.staticType;
|
| - return copy;
|
| - }
|
| -
|
| - @override
|
| - AstNode visitNativeClause(NativeClause node) =>
|
| - new NativeClause(_mapToken(node.nativeKeyword), _cloneNode(node.name));
|
| -
|
| - @override
|
| - NativeFunctionBody visitNativeFunctionBody(NativeFunctionBody node) =>
|
| - new NativeFunctionBody(_mapToken(node.nativeKeyword),
|
| - _cloneNode(node.stringLiteral), _mapToken(node.semicolon));
|
| -
|
| - @override
|
| - NullLiteral visitNullLiteral(NullLiteral node) {
|
| - NullLiteral copy = new NullLiteral(_mapToken(node.literal));
|
| - copy.propagatedType = node.propagatedType;
|
| - copy.staticType = node.staticType;
|
| - return copy;
|
| - }
|
| -
|
| - @override
|
| - ParenthesizedExpression visitParenthesizedExpression(
|
| - ParenthesizedExpression node) {
|
| - ParenthesizedExpression copy = new ParenthesizedExpression(
|
| - _mapToken(node.leftParenthesis), _cloneNode(node.expression),
|
| - _mapToken(node.rightParenthesis));
|
| - copy.propagatedType = node.propagatedType;
|
| - copy.staticType = node.staticType;
|
| - return copy;
|
| - }
|
| -
|
| - @override
|
| - PartDirective visitPartDirective(PartDirective node) {
|
| - PartDirective copy = new PartDirective(
|
| - _cloneNode(node.documentationComment), _cloneNodeList(node.metadata),
|
| - _mapToken(node.partKeyword), _cloneNode(node.uri),
|
| - _mapToken(node.semicolon));
|
| - copy.element = node.element;
|
| - return copy;
|
| - }
|
| -
|
| - @override
|
| - PartOfDirective visitPartOfDirective(PartOfDirective node) {
|
| - PartOfDirective copy = new PartOfDirective(
|
| - _cloneNode(node.documentationComment), _cloneNodeList(node.metadata),
|
| - _mapToken(node.partKeyword), _mapToken(node.ofKeyword),
|
| - _cloneNode(node.libraryName), _mapToken(node.semicolon));
|
| - copy.element = node.element;
|
| - return copy;
|
| - }
|
| -
|
| - @override
|
| - PostfixExpression visitPostfixExpression(PostfixExpression node) {
|
| - PostfixExpression copy = new PostfixExpression(
|
| - _cloneNode(node.operand), _mapToken(node.operator));
|
| - copy.propagatedElement = node.propagatedElement;
|
| - copy.propagatedType = node.propagatedType;
|
| - copy.staticElement = node.staticElement;
|
| - copy.staticType = node.staticType;
|
| - return copy;
|
| - }
|
| -
|
| - @override
|
| - PrefixedIdentifier visitPrefixedIdentifier(PrefixedIdentifier node) {
|
| - PrefixedIdentifier copy = new PrefixedIdentifier(_cloneNode(node.prefix),
|
| - _mapToken(node.period), _cloneNode(node.identifier));
|
| - copy.propagatedType = node.propagatedType;
|
| - copy.staticType = node.staticType;
|
| - return copy;
|
| - }
|
| -
|
| - @override
|
| - PrefixExpression visitPrefixExpression(PrefixExpression node) {
|
| - PrefixExpression copy = new PrefixExpression(
|
| - _mapToken(node.operator), _cloneNode(node.operand));
|
| - copy.propagatedElement = node.propagatedElement;
|
| - copy.propagatedType = node.propagatedType;
|
| - copy.staticElement = node.staticElement;
|
| - copy.staticType = node.staticType;
|
| - return copy;
|
| - }
|
| -
|
| - @override
|
| - PropertyAccess visitPropertyAccess(PropertyAccess node) {
|
| - PropertyAccess copy = new PropertyAccess(_cloneNode(node.target),
|
| - _mapToken(node.operator), _cloneNode(node.propertyName));
|
| - copy.propagatedType = node.propagatedType;
|
| - copy.staticType = node.staticType;
|
| - return copy;
|
| - }
|
| -
|
| - @override
|
| - RedirectingConstructorInvocation visitRedirectingConstructorInvocation(
|
| - RedirectingConstructorInvocation node) {
|
| - RedirectingConstructorInvocation copy =
|
| - new RedirectingConstructorInvocation(_mapToken(node.thisKeyword),
|
| - _mapToken(node.period), _cloneNode(node.constructorName),
|
| - _cloneNode(node.argumentList));
|
| - copy.staticElement = node.staticElement;
|
| - return copy;
|
| - }
|
| -
|
| - @override
|
| - RethrowExpression visitRethrowExpression(RethrowExpression node) {
|
| - RethrowExpression copy =
|
| - new RethrowExpression(_mapToken(node.rethrowKeyword));
|
| - copy.propagatedType = node.propagatedType;
|
| - copy.staticType = node.staticType;
|
| - return copy;
|
| - }
|
| -
|
| - @override
|
| - ReturnStatement visitReturnStatement(ReturnStatement node) =>
|
| - new ReturnStatement(_mapToken(node.returnKeyword),
|
| - _cloneNode(node.expression), _mapToken(node.semicolon));
|
| -
|
| - @override
|
| - ScriptTag visitScriptTag(ScriptTag node) =>
|
| - new ScriptTag(_mapToken(node.scriptTag));
|
| -
|
| - @override
|
| - ShowCombinator visitShowCombinator(ShowCombinator node) => new ShowCombinator(
|
| - _mapToken(node.keyword), _cloneNodeList(node.shownNames));
|
| -
|
| - @override
|
| - SimpleFormalParameter visitSimpleFormalParameter(
|
| - SimpleFormalParameter node) => new SimpleFormalParameter(
|
| - _cloneNode(node.documentationComment), _cloneNodeList(node.metadata),
|
| - _mapToken(node.keyword), _cloneNode(node.type),
|
| - _cloneNode(node.identifier));
|
| -
|
| - @override
|
| - SimpleIdentifier visitSimpleIdentifier(SimpleIdentifier node) {
|
| - Token mappedToken = _mapToken(node.token);
|
| - if (mappedToken == null) {
|
| - // This only happens for SimpleIdentifiers created by the parser as part
|
| - // of scanning documentation comments (the tokens for those identifiers
|
| - // are not in the original token stream and hence do not get copied).
|
| - // This extra check can be removed if the scanner is changed to scan
|
| - // documentation comments for the parser.
|
| - mappedToken = node.token;
|
| - }
|
| - SimpleIdentifier copy = new SimpleIdentifier(mappedToken);
|
| - copy.auxiliaryElements = node.auxiliaryElements;
|
| - copy.propagatedElement = node.propagatedElement;
|
| - copy.propagatedType = node.propagatedType;
|
| - copy.staticElement = node.staticElement;
|
| - copy.staticType = node.staticType;
|
| - return copy;
|
| - }
|
| -
|
| - @override
|
| - SimpleStringLiteral visitSimpleStringLiteral(SimpleStringLiteral node) {
|
| - SimpleStringLiteral copy =
|
| - new SimpleStringLiteral(_mapToken(node.literal), node.value);
|
| - copy.propagatedType = node.propagatedType;
|
| - copy.staticType = node.staticType;
|
| - return copy;
|
| - }
|
| -
|
| - @override
|
| - StringInterpolation visitStringInterpolation(StringInterpolation node) {
|
| - StringInterpolation copy =
|
| - new StringInterpolation(_cloneNodeList(node.elements));
|
| - copy.propagatedType = node.propagatedType;
|
| - copy.staticType = node.staticType;
|
| - return copy;
|
| - }
|
| -
|
| - @override
|
| - SuperConstructorInvocation visitSuperConstructorInvocation(
|
| - SuperConstructorInvocation node) {
|
| - SuperConstructorInvocation copy = new SuperConstructorInvocation(
|
| - _mapToken(node.superKeyword), _mapToken(node.period),
|
| - _cloneNode(node.constructorName), _cloneNode(node.argumentList));
|
| - copy.staticElement = node.staticElement;
|
| - return copy;
|
| - }
|
| -
|
| - @override
|
| - SuperExpression visitSuperExpression(SuperExpression node) {
|
| - SuperExpression copy = new SuperExpression(_mapToken(node.superKeyword));
|
| - copy.propagatedType = node.propagatedType;
|
| - copy.staticType = node.staticType;
|
| - return copy;
|
| - }
|
| -
|
| - @override
|
| - SwitchCase visitSwitchCase(SwitchCase node) => new SwitchCase(
|
| - _cloneNodeList(node.labels), _mapToken(node.keyword),
|
| - _cloneNode(node.expression), _mapToken(node.colon),
|
| - _cloneNodeList(node.statements));
|
| -
|
| - @override
|
| - SwitchDefault visitSwitchDefault(SwitchDefault node) => new SwitchDefault(
|
| - _cloneNodeList(node.labels), _mapToken(node.keyword),
|
| - _mapToken(node.colon), _cloneNodeList(node.statements));
|
| -
|
| - @override
|
| - SwitchStatement visitSwitchStatement(SwitchStatement node) =>
|
| - new SwitchStatement(_mapToken(node.switchKeyword),
|
| - _mapToken(node.leftParenthesis), _cloneNode(node.expression),
|
| - _mapToken(node.rightParenthesis), _mapToken(node.leftBracket),
|
| - _cloneNodeList(node.members), _mapToken(node.rightBracket));
|
| -
|
| - @override
|
| - AstNode visitSymbolLiteral(SymbolLiteral node) {
|
| - SymbolLiteral copy = new SymbolLiteral(
|
| - _mapToken(node.poundSign), _mapTokens(node.components));
|
| - copy.propagatedType = node.propagatedType;
|
| - copy.staticType = node.staticType;
|
| - return copy;
|
| - }
|
| -
|
| - @override
|
| - ThisExpression visitThisExpression(ThisExpression node) {
|
| - ThisExpression copy = new ThisExpression(_mapToken(node.thisKeyword));
|
| - copy.propagatedType = node.propagatedType;
|
| - copy.staticType = node.staticType;
|
| - return copy;
|
| - }
|
| -
|
| - @override
|
| - ThrowExpression visitThrowExpression(ThrowExpression node) {
|
| - ThrowExpression copy = new ThrowExpression(
|
| - _mapToken(node.throwKeyword), _cloneNode(node.expression));
|
| - copy.propagatedType = node.propagatedType;
|
| - copy.staticType = node.staticType;
|
| - return copy;
|
| - }
|
| -
|
| - @override
|
| - TopLevelVariableDeclaration visitTopLevelVariableDeclaration(
|
| - TopLevelVariableDeclaration node) => new TopLevelVariableDeclaration(
|
| - _cloneNode(node.documentationComment), _cloneNodeList(node.metadata),
|
| - _cloneNode(node.variables), _mapToken(node.semicolon));
|
| -
|
| - @override
|
| - TryStatement visitTryStatement(TryStatement node) => new TryStatement(
|
| - _mapToken(node.tryKeyword), _cloneNode(node.body),
|
| - _cloneNodeList(node.catchClauses), _mapToken(node.finallyKeyword),
|
| - _cloneNode(node.finallyBlock));
|
| -
|
| - @override
|
| - TypeArgumentList visitTypeArgumentList(TypeArgumentList node) =>
|
| - new TypeArgumentList(_mapToken(node.leftBracket),
|
| - _cloneNodeList(node.arguments), _mapToken(node.rightBracket));
|
| -
|
| - @override
|
| - TypeName visitTypeName(TypeName node) {
|
| - TypeName copy =
|
| - new TypeName(_cloneNode(node.name), _cloneNode(node.typeArguments));
|
| - copy.type = node.type;
|
| - return copy;
|
| - }
|
| -
|
| - @override
|
| - TypeParameter visitTypeParameter(TypeParameter node) => new TypeParameter(
|
| - _cloneNode(node.documentationComment), _cloneNodeList(node.metadata),
|
| - _cloneNode(node.name), _mapToken(node.extendsKeyword),
|
| - _cloneNode(node.bound));
|
| -
|
| - @override
|
| - TypeParameterList visitTypeParameterList(TypeParameterList node) =>
|
| - new TypeParameterList(_mapToken(node.leftBracket),
|
| - _cloneNodeList(node.typeParameters), _mapToken(node.rightBracket));
|
| -
|
| - @override
|
| - VariableDeclaration visitVariableDeclaration(VariableDeclaration node) =>
|
| - new VariableDeclaration(_cloneNode(node.name), _mapToken(node.equals),
|
| - _cloneNode(node.initializer));
|
| -
|
| - @override
|
| - VariableDeclarationList visitVariableDeclarationList(
|
| - VariableDeclarationList node) => new VariableDeclarationList(null,
|
| - _cloneNodeList(node.metadata), _mapToken(node.keyword),
|
| - _cloneNode(node.type), _cloneNodeList(node.variables));
|
| -
|
| - @override
|
| - VariableDeclarationStatement visitVariableDeclarationStatement(
|
| - VariableDeclarationStatement node) => new VariableDeclarationStatement(
|
| - _cloneNode(node.variables), _mapToken(node.semicolon));
|
| -
|
| - @override
|
| - WhileStatement visitWhileStatement(WhileStatement node) => new WhileStatement(
|
| - _mapToken(node.whileKeyword), _mapToken(node.leftParenthesis),
|
| - _cloneNode(node.condition), _mapToken(node.rightParenthesis),
|
| - _cloneNode(node.body));
|
| -
|
| - @override
|
| - WithClause visitWithClause(WithClause node) => new WithClause(
|
| - _mapToken(node.withKeyword), _cloneNodeList(node.mixinTypes));
|
| -
|
| - @override
|
| - YieldStatement visitYieldStatement(YieldStatement node) => new YieldStatement(
|
| - _mapToken(node.yieldKeyword), _mapToken(node.star),
|
| - _cloneNode(node.expression), _mapToken(node.semicolon));
|
| -
|
| - AstNode _cloneNode(AstNode node) {
|
| - if (node == null) {
|
| - return null;
|
| - }
|
| - if (identical(node, _oldNode)) {
|
| - return _newNode;
|
| - }
|
| - return node.accept(this) as AstNode;
|
| - }
|
| -
|
| - List _cloneNodeList(NodeList nodes) {
|
| - List clonedNodes = new List();
|
| - for (AstNode node in nodes) {
|
| - clonedNodes.add(_cloneNode(node));
|
| - }
|
| - return clonedNodes;
|
| - }
|
| -
|
| - Token _mapToken(Token oldToken) {
|
| - if (oldToken == null) {
|
| - return null;
|
| - }
|
| - return _tokenMap.get(oldToken);
|
| - }
|
| -
|
| - List<Token> _mapTokens(List<Token> oldTokens) {
|
| - List<Token> newTokens = new List<Token>(oldTokens.length);
|
| - for (int index = 0; index < newTokens.length; index++) {
|
| - newTokens[index] = _mapToken(oldTokens[index]);
|
| - }
|
| - return newTokens;
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * An index expression.
|
| - *
|
| - * > indexExpression ::=
|
| - * > [Expression] '[' [Expression] ']'
|
| - */
|
| -class IndexExpression extends Expression {
|
| - /**
|
| - * The expression used to compute the object being indexed, or `null` if this
|
| - * index expression is part of a cascade expression.
|
| - */
|
| - Expression _target;
|
| -
|
| - /**
|
| - * The period ("..") before a cascaded index expression, or `null` if this
|
| - * index expression is not part of a cascade expression.
|
| - */
|
| - Token period;
|
| -
|
| - /**
|
| - * The left square bracket.
|
| - */
|
| - Token leftBracket;
|
| -
|
| - /**
|
| - * The expression used to compute the index.
|
| - */
|
| - Expression _index;
|
| -
|
| - /**
|
| - * The right square bracket.
|
| - */
|
| - Token rightBracket;
|
| -
|
| - /**
|
| - * The element associated with the operator based on the static type of the
|
| - * target, or `null` if the AST structure has not been resolved or if the
|
| - * operator could not be resolved.
|
| - */
|
| - MethodElement staticElement;
|
| -
|
| - /**
|
| - * The element associated with the operator based on the propagated type of
|
| - * the target, or `null` if the AST structure has not been resolved or if the
|
| - * operator could not be resolved.
|
| - */
|
| - MethodElement propagatedElement;
|
| -
|
| - /**
|
| - * If this expression is both in a getter and setter context, the
|
| - * [AuxiliaryElements] will be set to hold onto the static and propagated
|
| - * information. The auxiliary element will hold onto the elements from the
|
| - * getter context.
|
| - */
|
| - AuxiliaryElements auxiliaryElements = null;
|
| -
|
| - /**
|
| - * Initialize a newly created index expression.
|
| - */
|
| - IndexExpression.forCascade(
|
| - this.period, this.leftBracket, Expression index, this.rightBracket) {
|
| - _index = _becomeParentOf(index);
|
| - }
|
| -
|
| - /**
|
| - * Initialize a newly created index expression.
|
| - */
|
| - IndexExpression.forTarget(Expression target, this.leftBracket,
|
| - Expression index, this.rightBracket) {
|
| - _target = _becomeParentOf(target);
|
| - _index = _becomeParentOf(index);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken {
|
| - if (_target != null) {
|
| - return _target.beginToken;
|
| - }
|
| - return period;
|
| - }
|
| -
|
| - /**
|
| - * Return the best element available for this operator. If resolution was able
|
| - * to find a better element based on type propagation, that element will be
|
| - * returned. Otherwise, the element found using the result of static analysis
|
| - * will be returned. If resolution has not been performed, then `null` will be
|
| - * returned.
|
| - */
|
| - MethodElement get bestElement {
|
| - MethodElement element = propagatedElement;
|
| - if (element == null) {
|
| - element = staticElement;
|
| - }
|
| - return element;
|
| - }
|
| -
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()
|
| - ..add(_target)
|
| - ..add(period)
|
| - ..add(leftBracket)
|
| - ..add(_index)
|
| - ..add(rightBracket);
|
| -
|
| - @override
|
| - Token get endToken => rightBracket;
|
| -
|
| - /**
|
| - * Return the expression used to compute the index.
|
| - */
|
| - Expression get index => _index;
|
| -
|
| - /**
|
| - * Set the expression used to compute the index to the given [expression].
|
| - */
|
| - void set index(Expression expression) {
|
| - _index = _becomeParentOf(expression);
|
| - }
|
| -
|
| - @override
|
| - bool get isAssignable => true;
|
| -
|
| - /**
|
| - * Return `true` if this expression is cascaded. If it is, then the target of
|
| - * this expression is not stored locally but is stored in the nearest ancestor
|
| - * that is a [CascadeExpression].
|
| - */
|
| - bool get isCascaded => period != null;
|
| -
|
| - @override
|
| - int get precedence => 15;
|
| -
|
| - /**
|
| - * If the AST structure has been resolved, and the function being invoked is
|
| - * known based on propagated type information, then return the parameter
|
| - * element representing the parameter to which the value of the index
|
| - * expression will be bound. Otherwise, return `null`.
|
| - */
|
| - @deprecated // Use "expression.propagatedParameterElement"
|
| - ParameterElement get propagatedParameterElementForIndex {
|
| - return _propagatedParameterElementForIndex;
|
| - }
|
| -
|
| - /**
|
| - * Return the expression used to compute the object being indexed. If this
|
| - * index expression is not part of a cascade expression, then this is the same
|
| - * as [target]. If this index expression is part of a cascade expression, then
|
| - * the target expression stored with the cascade expression is returned.
|
| - */
|
| - Expression get realTarget {
|
| - if (isCascaded) {
|
| - AstNode ancestor = parent;
|
| - while (ancestor is! CascadeExpression) {
|
| - if (ancestor == null) {
|
| - return _target;
|
| - }
|
| - ancestor = ancestor.parent;
|
| - }
|
| - return (ancestor as CascadeExpression).target;
|
| - }
|
| - return _target;
|
| - }
|
| -
|
| - /**
|
| - * If the AST structure has been resolved, and the function being invoked is
|
| - * known based on static type information, then return the parameter element
|
| - * representing the parameter to which the value of the index expression will
|
| - * be bound. Otherwise, return `null`.
|
| - */
|
| - @deprecated // Use "expression.propagatedParameterElement"
|
| - ParameterElement get staticParameterElementForIndex {
|
| - return _staticParameterElementForIndex;
|
| - }
|
| -
|
| - /**
|
| - * Return the expression used to compute the object being indexed, or `null`
|
| - * if this index expression is part of a cascade expression.
|
| - *
|
| - * Use [realTarget] to get the target independent of whether this is part of a
|
| - * cascade expression.
|
| - */
|
| - Expression get target => _target;
|
| -
|
| - /**
|
| - * Set the expression used to compute the object being indexed to the given
|
| - * [expression].
|
| - */
|
| - void set target(Expression expression) {
|
| - _target = _becomeParentOf(expression);
|
| - }
|
| -
|
| - /**
|
| - * If the AST structure has been resolved, and the function being invoked is
|
| - * known based on propagated type information, then return the parameter
|
| - * element representing the parameter to which the value of the index
|
| - * expression will be bound. Otherwise, return `null`.
|
| - */
|
| - ParameterElement get _propagatedParameterElementForIndex {
|
| - if (propagatedElement == null) {
|
| - return null;
|
| - }
|
| - List<ParameterElement> parameters = propagatedElement.parameters;
|
| - if (parameters.length < 1) {
|
| - return null;
|
| - }
|
| - return parameters[0];
|
| - }
|
| -
|
| - /**
|
| - * If the AST structure has been resolved, and the function being invoked is
|
| - * known based on static type information, then return the parameter element
|
| - * representing the parameter to which the value of the index expression will
|
| - * be bound. Otherwise, return `null`.
|
| - */
|
| - ParameterElement get _staticParameterElementForIndex {
|
| - if (staticElement == null) {
|
| - return null;
|
| - }
|
| - List<ParameterElement> parameters = staticElement.parameters;
|
| - if (parameters.length < 1) {
|
| - return null;
|
| - }
|
| - return parameters[0];
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitIndexExpression(this);
|
| -
|
| - /**
|
| - * Return `true` if this expression is computing a right-hand value (that is,
|
| - * if this expression is in a context where the operator '[]' will be
|
| - * invoked).
|
| - *
|
| - * Note that [inGetterContext] and [inSetterContext] are not opposites, nor
|
| - * are they mutually exclusive. In other words, it is possible for both
|
| - * methods to return `true` when invoked on the same node.
|
| - */
|
| - bool inGetterContext() {
|
| - // TODO(brianwilkerson) Convert this to a getter.
|
| - AstNode parent = this.parent;
|
| - if (parent is AssignmentExpression) {
|
| - AssignmentExpression assignment = parent;
|
| - if (identical(assignment.leftHandSide, this) &&
|
| - assignment.operator.type == TokenType.EQ) {
|
| - return false;
|
| - }
|
| - }
|
| - return true;
|
| - }
|
| -
|
| - /**
|
| - * Return `true` if this expression is computing a left-hand value (that is,
|
| - * if this expression is in a context where the operator '[]=' will be
|
| - * invoked).
|
| - *
|
| - * Note that [inGetterContext] and [inSetterContext] are not opposites, nor
|
| - * are they mutually exclusive. In other words, it is possible for both
|
| - * methods to return `true` when invoked on the same node.
|
| - */
|
| - bool inSetterContext() {
|
| - // TODO(brianwilkerson) Convert this to a getter.
|
| - AstNode parent = this.parent;
|
| - if (parent is PrefixExpression) {
|
| - return parent.operator.type.isIncrementOperator;
|
| - } else if (parent is PostfixExpression) {
|
| - return true;
|
| - } else if (parent is AssignmentExpression) {
|
| - return identical(parent.leftHandSide, this);
|
| - }
|
| - return false;
|
| - }
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_target, visitor);
|
| - _safelyVisitChild(_index, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * An instance creation expression.
|
| - *
|
| - * > newExpression ::=
|
| - * > ('new' | 'const') [TypeName] ('.' [SimpleIdentifier])? [ArgumentList]
|
| - */
|
| -class InstanceCreationExpression extends Expression {
|
| - /**
|
| - * The 'new' or 'const' keyword used to indicate how an object should be
|
| - * created.
|
| - */
|
| - Token keyword;
|
| -
|
| - /**
|
| - * The name of the constructor to be invoked.
|
| - */
|
| - ConstructorName _constructorName;
|
| -
|
| - /**
|
| - * The list of arguments to the constructor.
|
| - */
|
| - ArgumentList _argumentList;
|
| -
|
| - /**
|
| - * The element associated with the constructor based on static type
|
| - * information, or `null` if the AST structure has not been resolved or if the
|
| - * constructor could not be resolved.
|
| - */
|
| - ConstructorElement staticElement;
|
| -
|
| - /**
|
| - * Initialize a newly created instance creation expression.
|
| - */
|
| - InstanceCreationExpression(this.keyword, ConstructorName constructorName,
|
| - ArgumentList argumentList) {
|
| - _constructorName = _becomeParentOf(constructorName);
|
| - _argumentList = _becomeParentOf(argumentList);
|
| - }
|
| -
|
| - /**
|
| - * Return the list of arguments to the constructor.
|
| - */
|
| - ArgumentList get argumentList => _argumentList;
|
| -
|
| - /**
|
| - * Set the list of arguments to the constructor to the given [argumentList].
|
| - */
|
| - void set argumentList(ArgumentList argumentList) {
|
| - _argumentList = _becomeParentOf(argumentList);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => keyword;
|
| -
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()
|
| - ..add(keyword)
|
| - ..add(_constructorName)
|
| - ..add(_argumentList);
|
| -
|
| - /**
|
| - * Return the name of the constructor to be invoked.
|
| - */
|
| - ConstructorName get constructorName => _constructorName;
|
| -
|
| - /**
|
| - * Set the name of the constructor to be invoked to the given [name].
|
| - */
|
| - void set constructorName(ConstructorName name) {
|
| - _constructorName = _becomeParentOf(name);
|
| - }
|
| -
|
| - @override
|
| - Token get endToken => _argumentList.endToken;
|
| -
|
| - /**
|
| - * Return `true` if this creation expression is used to invoke a constant
|
| - * constructor.
|
| - */
|
| - bool get isConst => keyword is KeywordToken &&
|
| - (keyword as KeywordToken).keyword == Keyword.CONST;
|
| -
|
| - @override
|
| - int get precedence => 16;
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitInstanceCreationExpression(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_constructorName, visitor);
|
| - _safelyVisitChild(_argumentList, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * An integer literal expression.
|
| - *
|
| - * > integerLiteral ::=
|
| - * > decimalIntegerLiteral
|
| - * > | hexidecimalIntegerLiteral
|
| - * >
|
| - * > decimalIntegerLiteral ::=
|
| - * > decimalDigit+
|
| - * >
|
| - * > hexidecimalIntegerLiteral ::=
|
| - * > '0x' hexidecimalDigit+
|
| - * > | '0X' hexidecimalDigit+
|
| - */
|
| -class IntegerLiteral extends Literal {
|
| - /**
|
| - * The token representing the literal.
|
| - */
|
| - Token literal;
|
| -
|
| - /**
|
| - * The value of the literal.
|
| - */
|
| - int value = 0;
|
| -
|
| - /**
|
| - * Initialize a newly created integer literal.
|
| - */
|
| - IntegerLiteral(this.literal, this.value);
|
| -
|
| - @override
|
| - Token get beginToken => literal;
|
| -
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()..add(literal);
|
| -
|
| - @override
|
| - Token get endToken => literal;
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitIntegerLiteral(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - // There are no children to visit.
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A node within a [StringInterpolation].
|
| - *
|
| - * > interpolationElement ::=
|
| - * > [InterpolationExpression]
|
| - * > | [InterpolationString]
|
| - */
|
| -abstract class InterpolationElement extends AstNode {}
|
| -
|
| -/**
|
| - * An expression embedded in a string interpolation.
|
| - *
|
| - * > interpolationExpression ::=
|
| - * > '$' [SimpleIdentifier]
|
| - * > | '$' '{' [Expression] '}'
|
| - */
|
| -class InterpolationExpression extends InterpolationElement {
|
| - /**
|
| - * The token used to introduce the interpolation expression; either '$' if the
|
| - * expression is a simple identifier or '${' if the expression is a full
|
| - * expression.
|
| - */
|
| - Token leftBracket;
|
| -
|
| - /**
|
| - * The expression to be evaluated for the value to be converted into a string.
|
| - */
|
| - Expression _expression;
|
| -
|
| - /**
|
| - * The right curly bracket, or `null` if the expression is an identifier
|
| - * without brackets.
|
| - */
|
| - Token rightBracket;
|
| -
|
| - /**
|
| - * Initialize a newly created interpolation expression.
|
| - */
|
| - InterpolationExpression(
|
| - this.leftBracket, Expression expression, this.rightBracket) {
|
| - _expression = _becomeParentOf(expression);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => leftBracket;
|
| -
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()
|
| - ..add(leftBracket)
|
| - ..add(_expression)
|
| - ..add(rightBracket);
|
| -
|
| - @override
|
| - Token get endToken {
|
| - if (rightBracket != null) {
|
| - return rightBracket;
|
| - }
|
| - return _expression.endToken;
|
| - }
|
| -
|
| - /**
|
| - * Return the expression to be evaluated for the value to be converted into a
|
| - * string.
|
| - */
|
| - Expression get expression => _expression;
|
| -
|
| - /**
|
| - * Set the expression to be evaluated for the value to be converted into a
|
| - * string to the given [expression].
|
| - */
|
| - void set expression(Expression expression) {
|
| - _expression = _becomeParentOf(expression);
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitInterpolationExpression(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_expression, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A non-empty substring of an interpolated string.
|
| - *
|
| - * > interpolationString ::=
|
| - * > characters
|
| - */
|
| -class InterpolationString extends InterpolationElement {
|
| - /**
|
| - * The characters that will be added to the string.
|
| - */
|
| - Token contents;
|
| -
|
| - /**
|
| - * The value of the literal.
|
| - */
|
| - String _value;
|
| -
|
| - /**
|
| - * Initialize a newly created string of characters that are part of a string
|
| - * interpolation.
|
| - */
|
| - InterpolationString(this.contents, String value) {
|
| - _value = value;
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => contents;
|
| -
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()..add(contents);
|
| -
|
| - /**
|
| - * Return the offset of the after-last contents character.
|
| - */
|
| - int get contentsEnd {
|
| - String lexeme = contents.lexeme;
|
| - return offset + new StringLexemeHelper(lexeme, true, true).end;
|
| - }
|
| -
|
| - /**
|
| - * Return the offset of the first contents character.
|
| - */
|
| - int get contentsOffset {
|
| - int offset = contents.offset;
|
| - String lexeme = contents.lexeme;
|
| - return offset + new StringLexemeHelper(lexeme, true, true).start;
|
| - }
|
| -
|
| - @override
|
| - Token get endToken => contents;
|
| -
|
| - /**
|
| - * Return the value of the literal.
|
| - */
|
| - String get value => _value;
|
| -
|
| - /**
|
| - * Set the value of the literal to the given [string].
|
| - */
|
| - void set value(String string) {
|
| - _value = string;
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitInterpolationString(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {}
|
| -}
|
| -
|
| -/**
|
| - * An is expression.
|
| - *
|
| - * > isExpression ::=
|
| - * > [Expression] 'is' '!'? [TypeName]
|
| - */
|
| -class IsExpression extends Expression {
|
| - /**
|
| - * The expression used to compute the value whose type is being tested.
|
| - */
|
| - Expression _expression;
|
| -
|
| - /**
|
| - * The is operator.
|
| - */
|
| - Token isOperator;
|
| -
|
| - /**
|
| - * The not operator, or `null` if the sense of the test is not negated.
|
| - */
|
| - Token notOperator;
|
| -
|
| - /**
|
| - * The name of the type being tested for.
|
| - */
|
| - TypeName _type;
|
| -
|
| - /**
|
| - * Initialize a newly created is expression. The [notOperator] can be `null`
|
| - * if the sense of the test is not negated.
|
| - */
|
| - IsExpression(
|
| - Expression expression, this.isOperator, this.notOperator, TypeName type) {
|
| - _expression = _becomeParentOf(expression);
|
| - _type = _becomeParentOf(type);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => _expression.beginToken;
|
| -
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()
|
| - ..add(_expression)
|
| - ..add(isOperator)
|
| - ..add(notOperator)
|
| - ..add(_type);
|
| -
|
| - @override
|
| - Token get endToken => _type.endToken;
|
| -
|
| - /**
|
| - * Return the expression used to compute the value whose type is being tested.
|
| - */
|
| - Expression get expression => _expression;
|
| -
|
| - /**
|
| - * Set the expression used to compute the value whose type is being tested to
|
| - * the given [expression].
|
| - */
|
| - void set expression(Expression expression) {
|
| - _expression = _becomeParentOf(expression);
|
| - }
|
| -
|
| - @override
|
| - int get precedence => 7;
|
| -
|
| - /**
|
| - * Return the name of the type being tested for.
|
| - */
|
| - TypeName get type => _type;
|
| -
|
| - /**
|
| - * Set the name of the type being tested for to the given [name].
|
| - */
|
| - void set type(TypeName name) {
|
| - _type = _becomeParentOf(name);
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitIsExpression(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_expression, visitor);
|
| - _safelyVisitChild(_type, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A label on either a [LabeledStatement] or a [NamedExpression].
|
| - *
|
| - * > label ::=
|
| - * > [SimpleIdentifier] ':'
|
| - */
|
| -class Label extends AstNode {
|
| - /**
|
| - * The label being associated with the statement.
|
| - */
|
| - SimpleIdentifier _label;
|
| -
|
| - /**
|
| - * The colon that separates the label from the statement.
|
| - */
|
| - Token colon;
|
| -
|
| - /**
|
| - * Initialize a newly created label.
|
| - */
|
| - Label(SimpleIdentifier label, this.colon) {
|
| - _label = _becomeParentOf(label);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => _label.beginToken;
|
| -
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()..add(_label)..add(colon);
|
| -
|
| - @override
|
| - Token get endToken => colon;
|
| -
|
| - /**
|
| - * Return the label being associated with the statement.
|
| - */
|
| - SimpleIdentifier get label => _label;
|
| -
|
| - /**
|
| - * Set the label being associated with the statement to the given [label].
|
| - */
|
| - void set label(SimpleIdentifier label) {
|
| - _label = _becomeParentOf(label);
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitLabel(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_label, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A statement that has a label associated with them.
|
| - *
|
| - * > labeledStatement ::=
|
| - * > [Label]+ [Statement]
|
| - */
|
| -class LabeledStatement extends Statement {
|
| - /**
|
| - * The labels being associated with the statement.
|
| - */
|
| - NodeList<Label> _labels;
|
| -
|
| - /**
|
| - * The statement with which the labels are being associated.
|
| - */
|
| - Statement _statement;
|
| -
|
| - /**
|
| - * Initialize a newly created labeled statement.
|
| - */
|
| - LabeledStatement(List<Label> labels, Statement statement) {
|
| - _labels = new NodeList<Label>(this, labels);
|
| - _statement = _becomeParentOf(statement);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken {
|
| - if (!_labels.isEmpty) {
|
| - return _labels.beginToken;
|
| - }
|
| - return _statement.beginToken;
|
| - }
|
| -
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()
|
| - ..addAll(_labels)
|
| - ..add(_statement);
|
| -
|
| - @override
|
| - Token get endToken => _statement.endToken;
|
| -
|
| - /**
|
| - * Return the labels being associated with the statement.
|
| - */
|
| - NodeList<Label> get labels => _labels;
|
| -
|
| - /**
|
| - * Return the statement with which the labels are being associated.
|
| - */
|
| - Statement get statement => _statement;
|
| -
|
| - /**
|
| - * Set the statement with which the labels are being associated to the given
|
| - * [statement].
|
| - */
|
| - void set statement(Statement statement) {
|
| - _statement = _becomeParentOf(statement);
|
| - }
|
| -
|
| - @override
|
| - Statement get unlabeled => _statement.unlabeled;
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitLabeledStatement(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _labels.accept(visitor);
|
| - _safelyVisitChild(_statement, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A library directive.
|
| - *
|
| - * > libraryDirective ::=
|
| - * > [Annotation] 'library' [Identifier] ';'
|
| - */
|
| -class LibraryDirective extends Directive {
|
| - /**
|
| - * The token representing the 'library' keyword.
|
| - */
|
| - Token libraryKeyword;
|
| -
|
| - /**
|
| - * The name of the library being defined.
|
| - */
|
| - LibraryIdentifier _name;
|
| -
|
| - /**
|
| - * The semicolon terminating the directive.
|
| - */
|
| - Token semicolon;
|
| -
|
| - /**
|
| - * Initialize a newly created library directive. Either or both of the
|
| - * [comment] and [metadata] can be `null` if the directive does not have the
|
| - * corresponding attribute.
|
| - */
|
| - LibraryDirective(Comment comment, List<Annotation> metadata,
|
| - this.libraryKeyword, LibraryIdentifier name, this.semicolon)
|
| - : super(comment, metadata) {
|
| - _name = _becomeParentOf(name);
|
| - }
|
| -
|
| - @override
|
| - Iterable get childEntities =>
|
| - super._childEntities..add(libraryKeyword)..add(_name)..add(semicolon);
|
| -
|
| - @override
|
| - Token get endToken => semicolon;
|
| -
|
| - @override
|
| - Token get firstTokenAfterCommentAndMetadata => libraryKeyword;
|
| -
|
| - @override
|
| - Token get keyword => libraryKeyword;
|
| -
|
| - /**
|
| - * Return the token representing the 'library' token.
|
| - */
|
| - @deprecated // Use "this.libraryKeyword"
|
| - Token get libraryToken => libraryKeyword;
|
| -
|
| - /**
|
| - * Set the token representing the 'library' token to the given [token].
|
| - */
|
| - @deprecated // Use "this.libraryKeyword"
|
| - set libraryToken(Token token) {
|
| - libraryKeyword = token;
|
| - }
|
| -
|
| - /**
|
| - * Return the name of the library being defined.
|
| - */
|
| - LibraryIdentifier get name => _name;
|
| -
|
| - /**
|
| - * Set the name of the library being defined to the given [name].
|
| - */
|
| - void set name(LibraryIdentifier name) {
|
| - _name = _becomeParentOf(name);
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitLibraryDirective(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - super.visitChildren(visitor);
|
| - _safelyVisitChild(_name, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * The identifier for a library.
|
| - *
|
| - * > libraryIdentifier ::=
|
| - * > [SimpleIdentifier] ('.' [SimpleIdentifier])*
|
| - */
|
| -class LibraryIdentifier extends Identifier {
|
| - /**
|
| - * The components of the identifier.
|
| - */
|
| - NodeList<SimpleIdentifier> _components;
|
| -
|
| - /**
|
| - * Initialize a newly created prefixed identifier.
|
| - */
|
| - LibraryIdentifier(List<SimpleIdentifier> components) {
|
| - _components = new NodeList<SimpleIdentifier>(this, components);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => _components.beginToken;
|
| -
|
| - @override
|
| - Element get bestElement => staticElement;
|
| -
|
| - /**
|
| - * TODO(paulberry): add "." tokens.
|
| - */
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()..addAll(_components);
|
| -
|
| - /**
|
| - * Return the components of the identifier.
|
| - */
|
| - NodeList<SimpleIdentifier> get components => _components;
|
| -
|
| - @override
|
| - Token get endToken => _components.endToken;
|
| -
|
| - @override
|
| - String get name {
|
| - StringBuffer buffer = new StringBuffer();
|
| - bool needsPeriod = false;
|
| - for (SimpleIdentifier identifier in _components) {
|
| - if (needsPeriod) {
|
| - buffer.write(".");
|
| - } else {
|
| - needsPeriod = true;
|
| - }
|
| - buffer.write(identifier.name);
|
| - }
|
| - return buffer.toString();
|
| - }
|
| -
|
| - @override
|
| - int get precedence => 15;
|
| -
|
| - @override
|
| - Element get propagatedElement => null;
|
| -
|
| - @override
|
| - Element get staticElement => null;
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitLibraryIdentifier(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _components.accept(visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A list literal.
|
| - *
|
| - * > listLiteral ::=
|
| - * > 'const'? ('<' [TypeName] '>')? '[' ([Expression] ','?)? ']'
|
| - */
|
| -class ListLiteral extends TypedLiteral {
|
| - /**
|
| - * The left square bracket.
|
| - */
|
| - Token leftBracket;
|
| -
|
| - /**
|
| - * The expressions used to compute the elements of the list.
|
| - */
|
| - NodeList<Expression> _elements;
|
| -
|
| - /**
|
| - * The right square bracket.
|
| - */
|
| - Token rightBracket;
|
| -
|
| - /**
|
| - * Initialize a newly created list literal. The [constKeyword] can be `null`
|
| - * if the literal is not a constant. The [typeArguments] can be `null` if no
|
| - * type arguments were declared. The list of [elements] can be `null` if the
|
| - * list is empty.
|
| - */
|
| - ListLiteral(Token constKeyword, TypeArgumentList typeArguments,
|
| - this.leftBracket, List<Expression> elements, this.rightBracket)
|
| - : super(constKeyword, typeArguments) {
|
| - _elements = new NodeList<Expression>(this, elements);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken {
|
| - if (constKeyword != null) {
|
| - return constKeyword;
|
| - }
|
| - TypeArgumentList typeArguments = this.typeArguments;
|
| - if (typeArguments != null) {
|
| - return typeArguments.beginToken;
|
| - }
|
| - return leftBracket;
|
| - }
|
| -
|
| - /**
|
| - * TODO(paulberry): add commas.
|
| - */
|
| - @override
|
| - Iterable get childEntities => super._childEntities
|
| - ..add(leftBracket)
|
| - ..addAll(_elements)
|
| - ..add(rightBracket);
|
| -
|
| - /**
|
| - * Return the expressions used to compute the elements of the list.
|
| - */
|
| - NodeList<Expression> get elements => _elements;
|
| -
|
| - @override
|
| - Token get endToken => rightBracket;
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitListLiteral(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - super.visitChildren(visitor);
|
| - _elements.accept(visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A node that represents a literal expression.
|
| - *
|
| - * > literal ::=
|
| - * > [BooleanLiteral]
|
| - * > | [DoubleLiteral]
|
| - * > | [IntegerLiteral]
|
| - * > | [ListLiteral]
|
| - * > | [MapLiteral]
|
| - * > | [NullLiteral]
|
| - * > | [StringLiteral]
|
| - */
|
| -abstract class Literal extends Expression {
|
| - @override
|
| - int get precedence => 16;
|
| -}
|
| -
|
| -/**
|
| - * A literal map.
|
| - *
|
| - * > mapLiteral ::=
|
| - * > 'const'? ('<' [TypeName] (',' [TypeName])* '>')?
|
| - * > '{' ([MapLiteralEntry] (',' [MapLiteralEntry])* ','?)? '}'
|
| - */
|
| -class MapLiteral extends TypedLiteral {
|
| - /**
|
| - * The left curly bracket.
|
| - */
|
| - Token leftBracket;
|
| -
|
| - /**
|
| - * The entries in the map.
|
| - */
|
| - NodeList<MapLiteralEntry> _entries;
|
| -
|
| - /**
|
| - * The right curly bracket.
|
| - */
|
| - Token rightBracket;
|
| -
|
| - /**
|
| - * Initialize a newly created map literal. The [constKeyword] can be `null` if
|
| - * the literal is not a constant. The [typeArguments] can be `null` if no type
|
| - * arguments were declared. The [entries] can be `null` if the map is empty.
|
| - */
|
| - MapLiteral(Token constKeyword, TypeArgumentList typeArguments,
|
| - this.leftBracket, List<MapLiteralEntry> entries, this.rightBracket)
|
| - : super(constKeyword, typeArguments) {
|
| - _entries = new NodeList<MapLiteralEntry>(this, entries);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken {
|
| - if (constKeyword != null) {
|
| - return constKeyword;
|
| - }
|
| - TypeArgumentList typeArguments = this.typeArguments;
|
| - if (typeArguments != null) {
|
| - return typeArguments.beginToken;
|
| - }
|
| - return leftBracket;
|
| - }
|
| -
|
| - /**
|
| - * TODO(paulberry): add commas.
|
| - */
|
| - @override
|
| - Iterable get childEntities => super._childEntities
|
| - ..add(leftBracket)
|
| - ..addAll(entries)
|
| - ..add(rightBracket);
|
| -
|
| - @override
|
| - Token get endToken => rightBracket;
|
| -
|
| - /**
|
| - * Return the entries in the map.
|
| - */
|
| - NodeList<MapLiteralEntry> get entries => _entries;
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitMapLiteral(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - super.visitChildren(visitor);
|
| - _entries.accept(visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A single key/value pair in a map literal.
|
| - *
|
| - * > mapLiteralEntry ::=
|
| - * > [Expression] ':' [Expression]
|
| - */
|
| -class MapLiteralEntry extends AstNode {
|
| - /**
|
| - * The expression computing the key with which the value will be associated.
|
| - */
|
| - Expression _key;
|
| -
|
| - /**
|
| - * The colon that separates the key from the value.
|
| - */
|
| - Token separator;
|
| -
|
| - /**
|
| - * The expression computing the value that will be associated with the key.
|
| - */
|
| - Expression _value;
|
| -
|
| - /**
|
| - * Initialize a newly created map literal entry.
|
| - */
|
| - MapLiteralEntry(Expression key, this.separator, Expression value) {
|
| - _key = _becomeParentOf(key);
|
| - _value = _becomeParentOf(value);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => _key.beginToken;
|
| -
|
| - @override
|
| - Iterable get childEntities =>
|
| - new ChildEntities()..add(_key)..add(separator)..add(_value);
|
| -
|
| - @override
|
| - Token get endToken => _value.endToken;
|
| -
|
| - /**
|
| - * Return the expression computing the key with which the value will be
|
| - * associated.
|
| - */
|
| - Expression get key => _key;
|
| -
|
| - /**
|
| - * Set the expression computing the key with which the value will be
|
| - * associated to the given [string].
|
| - */
|
| - void set key(Expression string) {
|
| - _key = _becomeParentOf(string);
|
| - }
|
| -
|
| - /**
|
| - * Return the expression computing the value that will be associated with the
|
| - * key.
|
| - */
|
| - Expression get value => _value;
|
| -
|
| - /**
|
| - * Set the expression computing the value that will be associated with the key
|
| - * to the given [expression].
|
| - */
|
| - void set value(Expression expression) {
|
| - _value = _becomeParentOf(expression);
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitMapLiteralEntry(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_key, visitor);
|
| - _safelyVisitChild(_value, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A method declaration.
|
| - *
|
| - * > methodDeclaration ::=
|
| - * > methodSignature [FunctionBody]
|
| - * >
|
| - * > methodSignature ::=
|
| - * > 'external'? ('abstract' | 'static')? [Type]? ('get' | 'set')?
|
| - * > methodName [TypeParameterList] [FormalParameterList]
|
| - * >
|
| - * > methodName ::=
|
| - * > [SimpleIdentifier]
|
| - * > | 'operator' [SimpleIdentifier]
|
| - */
|
| -class MethodDeclaration extends ClassMember {
|
| - /**
|
| - * The token for the 'external' keyword, or `null` if the constructor is not
|
| - * external.
|
| - */
|
| - Token externalKeyword;
|
| -
|
| - /**
|
| - * The token representing the 'abstract' or 'static' keyword, or `null` if
|
| - * neither modifier was specified.
|
| - */
|
| - Token modifierKeyword;
|
| -
|
| - /**
|
| - * The return type of the method, or `null` if no return type was declared.
|
| - */
|
| - TypeName _returnType;
|
| -
|
| - /**
|
| - * The token representing the 'get' or 'set' keyword, or `null` if this is a
|
| - * method declaration rather than a property declaration.
|
| - */
|
| - Token propertyKeyword;
|
| -
|
| - /**
|
| - * The token representing the 'operator' keyword, or `null` if this method
|
| - * does not declare an operator.
|
| - */
|
| - Token operatorKeyword;
|
| -
|
| - /**
|
| - * The name of the method.
|
| - */
|
| - SimpleIdentifier _name;
|
| -
|
| - /**
|
| - * The type parameters associated with the method, or `null` if the method is
|
| - * not a generic method.
|
| - */
|
| - TypeParameterList _typeParameters;
|
| -
|
| - /**
|
| - * The parameters associated with the method, or `null` if this method
|
| - * declares a getter.
|
| - */
|
| - FormalParameterList _parameters;
|
| -
|
| - /**
|
| - * The body of the method.
|
| - */
|
| - FunctionBody _body;
|
| -
|
| - /**
|
| - * Initialize a newly created method declaration. Either or both of the
|
| - * [comment] and [metadata] can be `null` if the declaration does not have the
|
| - * corresponding attribute. The [externalKeyword] can be `null` if the method
|
| - * is not external. The [modifierKeyword] can be `null` if the method is
|
| - * neither abstract nor static. The [returnType] can be `null` if no return
|
| - * type was specified. The [propertyKeyword] can be `null` if the method is
|
| - * neither a getter or a setter. The [operatorKeyword] can be `null` if the
|
| - * method does not implement an operator. The [parameters] must be `null` if
|
| - * this method declares a getter.
|
| - */
|
| - MethodDeclaration(Comment comment, List<Annotation> metadata,
|
| - this.externalKeyword, this.modifierKeyword, TypeName returnType,
|
| - this.propertyKeyword, this.operatorKeyword, SimpleIdentifier name,
|
| - TypeParameterList typeParameters, FormalParameterList parameters,
|
| - FunctionBody body)
|
| - : super(comment, metadata) {
|
| - _returnType = _becomeParentOf(returnType);
|
| - _name = _becomeParentOf(name);
|
| - _typeParameters = _becomeParentOf(typeParameters);
|
| - _parameters = _becomeParentOf(parameters);
|
| - _body = _becomeParentOf(body);
|
| - }
|
| -
|
| - /**
|
| - * Return the body of the method.
|
| - */
|
| - FunctionBody get body => _body;
|
| -
|
| - /**
|
| - * Set the body of the method to the given [functionBody].
|
| - */
|
| - void set body(FunctionBody functionBody) {
|
| - _body = _becomeParentOf(functionBody);
|
| - }
|
| -
|
| - @override
|
| - Iterable get childEntities => super._childEntities
|
| - ..add(externalKeyword)
|
| - ..add(modifierKeyword)
|
| - ..add(_returnType)
|
| - ..add(propertyKeyword)
|
| - ..add(operatorKeyword)
|
| - ..add(_name)
|
| - ..add(_parameters)
|
| - ..add(_body);
|
| -
|
| - /**
|
| - * Return the element associated with this method, or `null` if the AST
|
| - * structure has not been resolved. The element can either be a
|
| - * [MethodElement], if this represents the declaration of a normal method, or
|
| - * a [PropertyAccessorElement] if this represents the declaration of either a
|
| - * getter or a setter.
|
| - */
|
| - @override
|
| - ExecutableElement get element =>
|
| - _name != null ? (_name.staticElement as ExecutableElement) : null;
|
| -
|
| - @override
|
| - Token get endToken => _body.endToken;
|
| -
|
| - @override
|
| - Token get firstTokenAfterCommentAndMetadata {
|
| - if (modifierKeyword != null) {
|
| - return modifierKeyword;
|
| - } else if (_returnType != null) {
|
| - return _returnType.beginToken;
|
| - } else if (propertyKeyword != null) {
|
| - return propertyKeyword;
|
| - } else if (operatorKeyword != null) {
|
| - return operatorKeyword;
|
| - }
|
| - return _name.beginToken;
|
| - }
|
| -
|
| - /**
|
| - * Return `true` if this method is declared to be an abstract method.
|
| - */
|
| - bool get isAbstract {
|
| - FunctionBody body = _body;
|
| - return externalKeyword == null &&
|
| - (body is EmptyFunctionBody && !body.semicolon.isSynthetic);
|
| - }
|
| -
|
| - /**
|
| - * Return `true` if this method declares a getter.
|
| - */
|
| - bool get isGetter => propertyKeyword != null &&
|
| - (propertyKeyword as KeywordToken).keyword == Keyword.GET;
|
| -
|
| - /**
|
| - * Return `true` if this method declares an operator.
|
| - */
|
| - bool get isOperator => operatorKeyword != null;
|
| -
|
| - /**
|
| - * Return `true` if this method declares a setter.
|
| - */
|
| - bool get isSetter => propertyKeyword != null &&
|
| - (propertyKeyword as KeywordToken).keyword == Keyword.SET;
|
| -
|
| - /**
|
| - * Return `true` if this method is declared to be a static method.
|
| - */
|
| - bool get isStatic => modifierKeyword != null &&
|
| - (modifierKeyword as KeywordToken).keyword == Keyword.STATIC;
|
| -
|
| - /**
|
| - * Return the name of the method.
|
| - */
|
| - SimpleIdentifier get name => _name;
|
| -
|
| - /**
|
| - * Set the name of the method to the given [identifier].
|
| - */
|
| - void set name(SimpleIdentifier identifier) {
|
| - _name = _becomeParentOf(identifier);
|
| - }
|
| -
|
| - /**
|
| - * Return the parameters associated with the method, or `null` if this method
|
| - * declares a getter.
|
| - */
|
| - FormalParameterList get parameters => _parameters;
|
| -
|
| - /**
|
| - * Set the parameters associated with the method to the given list of
|
| - * [parameters].
|
| - */
|
| - void set parameters(FormalParameterList parameters) {
|
| - _parameters = _becomeParentOf(parameters);
|
| - }
|
| -
|
| - /**
|
| - * Return the return type of the method, or `null` if no return type was
|
| - * declared.
|
| - */
|
| - TypeName get returnType => _returnType;
|
| -
|
| - /**
|
| - * Set the return type of the method to the given [typeName].
|
| - */
|
| - void set returnType(TypeName typeName) {
|
| - _returnType = _becomeParentOf(typeName);
|
| - }
|
| -
|
| - /**
|
| - * Return the type parameters associated with this method, or `null` if this
|
| - * method is not a generic method.
|
| - */
|
| - TypeParameterList get typeParameters => _typeParameters;
|
| -
|
| - /**
|
| - * Set the type parameters associated with this method to the given
|
| - * [typeParameters].
|
| - */
|
| - void set typeParameters(TypeParameterList typeParameters) {
|
| - _typeParameters = _becomeParentOf(typeParameters);
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitMethodDeclaration(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - super.visitChildren(visitor);
|
| - _safelyVisitChild(_returnType, visitor);
|
| - _safelyVisitChild(_name, visitor);
|
| - _safelyVisitChild(_typeParameters, visitor);
|
| - _safelyVisitChild(_parameters, visitor);
|
| - _safelyVisitChild(_body, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * The invocation of either a function or a method. Invocations of functions
|
| - * resulting from evaluating an expression are represented by
|
| - * [FunctionExpressionInvocation] nodes. Invocations of getters and setters are
|
| - * represented by either [PrefixedIdentifier] or [PropertyAccess] nodes.
|
| - *
|
| - * > methodInvoction ::=
|
| - * > ([Expression] '.')? [SimpleIdentifier] [TypeArgumentList]? [ArgumentList]
|
| - */
|
| -class MethodInvocation extends Expression {
|
| - /**
|
| - * The expression producing the object on which the method is defined, or
|
| - * `null` if there is no target (that is, the target is implicitly `this`).
|
| - */
|
| - Expression _target;
|
| -
|
| - /**
|
| - * The operator that separates the target from the method name, or `null`
|
| - * if there is no target. In an ordinary method invocation this will be a
|
| - * period ('.'). In a cascade section this will be the cascade operator
|
| - * ('..').
|
| - */
|
| - Token operator;
|
| -
|
| - /**
|
| - * The name of the method being invoked.
|
| - */
|
| - SimpleIdentifier _methodName;
|
| -
|
| - /**
|
| - * The type arguments to be applied to the method being invoked, or `null` if
|
| - * no type arguments were provided.
|
| - */
|
| - TypeArgumentList _typeArguments;
|
| -
|
| - /**
|
| - * The list of arguments to the method.
|
| - */
|
| - ArgumentList _argumentList;
|
| -
|
| - /**
|
| - * Initialize a newly created method invocation. The [target] and [operator]
|
| - * can be `null` if there is no target.
|
| - */
|
| - MethodInvocation(Expression target, this.operator,
|
| - SimpleIdentifier methodName, TypeArgumentList typeArguments,
|
| - ArgumentList argumentList) {
|
| - _target = _becomeParentOf(target);
|
| - _methodName = _becomeParentOf(methodName);
|
| - _typeArguments = _becomeParentOf(typeArguments);
|
| - _argumentList = _becomeParentOf(argumentList);
|
| - }
|
| -
|
| - /**
|
| - * Return the list of arguments to the method.
|
| - */
|
| - ArgumentList get argumentList => _argumentList;
|
| -
|
| - /**
|
| - * Set the list of arguments to the method to the given [argumentList].
|
| - */
|
| - void set argumentList(ArgumentList argumentList) {
|
| - _argumentList = _becomeParentOf(argumentList);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken {
|
| - if (_target != null) {
|
| - return _target.beginToken;
|
| - } else if (operator != null) {
|
| - return operator;
|
| - }
|
| - return _methodName.beginToken;
|
| - }
|
| -
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()
|
| - ..add(_target)
|
| - ..add(operator)
|
| - ..add(_methodName)
|
| - ..add(_argumentList);
|
| -
|
| - @override
|
| - Token get endToken => _argumentList.endToken;
|
| -
|
| - /**
|
| - * Return `true` if this expression is cascaded. If it is, then the target of
|
| - * this expression is not stored locally but is stored in the nearest ancestor
|
| - * that is a [CascadeExpression].
|
| - */
|
| - bool get isCascaded =>
|
| - operator != null && operator.type == TokenType.PERIOD_PERIOD;
|
| -
|
| - /**
|
| - * Return the name of the method being invoked.
|
| - */
|
| - SimpleIdentifier get methodName => _methodName;
|
| -
|
| - /**
|
| - * Set the name of the method being invoked to the given [identifier].
|
| - */
|
| - void set methodName(SimpleIdentifier identifier) {
|
| - _methodName = _becomeParentOf(identifier);
|
| - }
|
| -
|
| - /**
|
| - * The operator that separates the target from the method name, or `null`
|
| - * if there is no target. In an ordinary method invocation this will be a
|
| - * period ('.'). In a cascade section this will be the cascade operator
|
| - * ('..').
|
| - */
|
| - @deprecated // Use this.operator
|
| - Token get period => operator;
|
| -
|
| - /**
|
| - * The operator that separates the target from the method name, or `null`
|
| - * if there is no target. In an ordinary method invocation this will be a
|
| - * period ('.'). In a cascade section this will be the cascade operator
|
| - * ('..').
|
| - */
|
| - @deprecated // Use this.operator
|
| - void set period(Token value) {
|
| - operator = value;
|
| - }
|
| -
|
| - @override
|
| - int get precedence => 15;
|
| -
|
| - /**
|
| - * Return the expression used to compute the receiver of the invocation. If
|
| - * this invocation is not part of a cascade expression, then this is the same
|
| - * as [target]. If this invocation is part of a cascade expression, then the
|
| - * target stored with the cascade expression is returned.
|
| - */
|
| - Expression get realTarget {
|
| - if (isCascaded) {
|
| - AstNode ancestor = parent;
|
| - while (ancestor is! CascadeExpression) {
|
| - if (ancestor == null) {
|
| - return _target;
|
| - }
|
| - ancestor = ancestor.parent;
|
| - }
|
| - return (ancestor as CascadeExpression).target;
|
| - }
|
| - return _target;
|
| - }
|
| -
|
| - /**
|
| - * Return the expression producing the object on which the method is defined,
|
| - * or `null` if there is no target (that is, the target is implicitly `this`)
|
| - * or if this method invocation is part of a cascade expression.
|
| - *
|
| - * Use [realTarget] to get the target independent of whether this is part of a
|
| - * cascade expression.
|
| - */
|
| - Expression get target => _target;
|
| -
|
| - /**
|
| - * Set the expression producing the object on which the method is defined to
|
| - * the given [expression].
|
| - */
|
| - void set target(Expression expression) {
|
| - _target = _becomeParentOf(expression);
|
| - }
|
| -
|
| - /**
|
| - * Return the type arguments to be applied to the method being invoked, or
|
| - * `null` if no type arguments were provided.
|
| - */
|
| - TypeArgumentList get typeArguments => _typeArguments;
|
| -
|
| - /**
|
| - * Set the type arguments to be applied to the method being invoked to the
|
| - * given [typeArguments].
|
| - */
|
| - void set typeArguments(TypeArgumentList typeArguments) {
|
| - _typeArguments = _becomeParentOf(typeArguments);
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitMethodInvocation(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_target, visitor);
|
| - _safelyVisitChild(_methodName, visitor);
|
| - _safelyVisitChild(_typeArguments, 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.
|
| - */
|
| - Label _name;
|
| -
|
| - /**
|
| - * The expression with which the name is associated.
|
| - */
|
| - Expression _expression;
|
| -
|
| - /**
|
| - * Initialize a newly created named expression..
|
| - */
|
| - NamedExpression(Label name, Expression expression) {
|
| - _name = _becomeParentOf(name);
|
| - _expression = _becomeParentOf(expression);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => _name.beginToken;
|
| -
|
| - @override
|
| - Iterable get childEntities =>
|
| - new ChildEntities()..add(_name)..add(_expression);
|
| -
|
| - /**
|
| - * Return the element representing the parameter being named by this
|
| - * expression, or `null` if the AST structure has not been resolved or if
|
| - * there is no parameter with the same name as this expression.
|
| - */
|
| - ParameterElement get element {
|
| - Element element = _name.label.staticElement;
|
| - if (element is ParameterElement) {
|
| - return element;
|
| - }
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Token get endToken => _expression.endToken;
|
| -
|
| - /**
|
| - * Return the expression with which the name is associated.
|
| - */
|
| - Expression get expression => _expression;
|
| -
|
| - /**
|
| - * Set the expression with which the name is associated to the given
|
| - * [expression].
|
| - */
|
| - void set expression(Expression expression) {
|
| - _expression = _becomeParentOf(expression);
|
| - }
|
| -
|
| - /**
|
| - * Return the name associated with the expression.
|
| - */
|
| - Label get name => _name;
|
| -
|
| - /**
|
| - * Set the name associated with the expression to the given [identifier].
|
| - */
|
| - void set name(Label identifier) {
|
| - _name = _becomeParentOf(identifier);
|
| - }
|
| -
|
| - @override
|
| - int get precedence => 0;
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitNamedExpression(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_name, visitor);
|
| - _safelyVisitChild(_expression, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A node that represents a directive that impacts the namespace of a library.
|
| - *
|
| - * > directive ::=
|
| - * > [ExportDirective]
|
| - * > | [ImportDirective]
|
| - */
|
| -abstract class NamespaceDirective extends UriBasedDirective {
|
| - /**
|
| - * The token representing the 'import' or 'export' keyword.
|
| - */
|
| - Token keyword;
|
| -
|
| - /**
|
| - * The combinators used to control which names are imported or exported.
|
| - */
|
| - NodeList<Combinator> _combinators;
|
| -
|
| - /**
|
| - * The semicolon terminating the directive.
|
| - */
|
| - Token semicolon;
|
| -
|
| - /**
|
| - * Initialize a newly created namespace directive. Either or both of the
|
| - * [comment] and [metadata] can be `null` if the directive does not have the
|
| - * corresponding attribute. The list of [combinators] can be `null` if there
|
| - * are no combinators.
|
| - */
|
| - NamespaceDirective(Comment comment, List<Annotation> metadata, this.keyword,
|
| - StringLiteral libraryUri, List<Combinator> combinators, this.semicolon)
|
| - : super(comment, metadata, libraryUri) {
|
| - _combinators = new NodeList<Combinator>(this, combinators);
|
| - }
|
| -
|
| - /**
|
| - * Return the combinators used to control how names are imported or exported.
|
| - */
|
| - NodeList<Combinator> get combinators => _combinators;
|
| -
|
| - @override
|
| - Token get endToken => semicolon;
|
| -
|
| - @override
|
| - Token get firstTokenAfterCommentAndMetadata => keyword;
|
| -
|
| - @override
|
| - LibraryElement get uriElement;
|
| -}
|
| -
|
| -/**
|
| - * The "native" clause in an class declaration.
|
| - *
|
| - * > nativeClause ::=
|
| - * > 'native' [StringLiteral]
|
| - */
|
| -class NativeClause extends AstNode {
|
| - /**
|
| - * The token representing the 'native' keyword.
|
| - */
|
| - Token nativeKeyword;
|
| -
|
| - /**
|
| - * The name of the native object that implements the class.
|
| - */
|
| - StringLiteral _name;
|
| -
|
| - /**
|
| - * Initialize a newly created native clause.
|
| - */
|
| - NativeClause(this.nativeKeyword, StringLiteral name) {
|
| - _name = _becomeParentOf(name);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => nativeKeyword;
|
| -
|
| - @override
|
| - Iterable get childEntities =>
|
| - new ChildEntities()..add(nativeKeyword)..add(_name);
|
| -
|
| - @override
|
| - Token get endToken => _name.endToken;
|
| -
|
| - /**
|
| - * Get the token representing the 'native' keyword.
|
| - */
|
| - @deprecated // Use "this.nativeKeyword"
|
| - Token get keyword => nativeKeyword;
|
| -
|
| - /**
|
| - * Set the token representing the 'native' keyword to the given [token].
|
| - */
|
| - @deprecated // Use "this.nativeKeyword"
|
| - set keyword(Token token) {
|
| - nativeKeyword = token;
|
| - }
|
| -
|
| - /**
|
| - * Return the name of the native object that implements the class.
|
| - */
|
| - StringLiteral get name => _name;
|
| -
|
| - /**
|
| - * Sets the name of the native object that implements the class to the given
|
| - * [name].
|
| - */
|
| - void set name(StringLiteral name) {
|
| - _name = _becomeParentOf(name);
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitNativeClause(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_name, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A function body that consists of a native keyword followed by a string
|
| - * literal.
|
| - *
|
| - * > nativeFunctionBody ::=
|
| - * > 'native' [SimpleStringLiteral] ';'
|
| - */
|
| -class NativeFunctionBody extends FunctionBody {
|
| - /**
|
| - * The token representing 'native' that marks the start of the function body.
|
| - */
|
| - Token nativeKeyword;
|
| -
|
| - /**
|
| - * The string literal, after the 'native' token.
|
| - */
|
| - StringLiteral _stringLiteral;
|
| -
|
| - /**
|
| - * The token representing the semicolon that marks the end of the function
|
| - * body.
|
| - */
|
| - Token semicolon;
|
| -
|
| - /**
|
| - * Initialize a newly created function body consisting of the 'native' token,
|
| - * a string literal, and a semicolon.
|
| - */
|
| - NativeFunctionBody(
|
| - this.nativeKeyword, StringLiteral stringLiteral, this.semicolon) {
|
| - _stringLiteral = _becomeParentOf(stringLiteral);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => nativeKeyword;
|
| -
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()
|
| - ..add(nativeKeyword)
|
| - ..add(_stringLiteral)
|
| - ..add(semicolon);
|
| -
|
| - @override
|
| - Token get endToken => semicolon;
|
| -
|
| - /**
|
| - * Return the token representing 'native' that marks the start of the function
|
| - * body.
|
| - */
|
| - @deprecated // Use "this.nativeKeyword"
|
| - Token get nativeToken => nativeKeyword;
|
| -
|
| - /**
|
| - * Set the token representing 'native' that marks the start of the function
|
| - * body to the given [token].
|
| - */
|
| - @deprecated // Use "this.nativeKeyword"
|
| - set nativeToken(Token token) {
|
| - nativeKeyword = token;
|
| - }
|
| -
|
| - /**
|
| - * Return the string literal representing the string after the 'native' token.
|
| - */
|
| - StringLiteral get stringLiteral => _stringLiteral;
|
| -
|
| - /**
|
| - * Set the string literal representing the string after the 'native' token to
|
| - * the given [stringLiteral].
|
| - */
|
| - void set stringLiteral(StringLiteral stringLiteral) {
|
| - _stringLiteral = _becomeParentOf(stringLiteral);
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitNativeFunctionBody(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_stringLiteral, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A list of AST nodes that have a common parent.
|
| - */
|
| -class NodeList<E extends AstNode> extends Object with ListMixin<E> {
|
| - /**
|
| - * The node that is the parent of each of the elements in the list.
|
| - */
|
| - AstNode owner;
|
| -
|
| - /**
|
| - * The elements contained in the list.
|
| - */
|
| - List<E> _elements = <E>[];
|
| -
|
| - /**
|
| - * Initialize a newly created list of nodes such that all of the nodes that
|
| - * are added to the list will have their parent set to the given [owner]. The
|
| - * list will initially be populated with the given [elements].
|
| - */
|
| - NodeList(this.owner, [List<E> elements]) {
|
| - addAll(elements);
|
| - }
|
| -
|
| - /**
|
| - * Return the first token included in this node list's source range, or `null`
|
| - * if the list is empty.
|
| - */
|
| - Token get beginToken {
|
| - if (_elements.length == 0) {
|
| - return null;
|
| - }
|
| - return _elements[0].beginToken;
|
| - }
|
| -
|
| - /**
|
| - * Return the last token included in this node list's source range, or `null`
|
| - * if the list is empty.
|
| - */
|
| - Token get endToken {
|
| - int length = _elements.length;
|
| - if (length == 0) {
|
| - return null;
|
| - }
|
| - return _elements[length - 1].endToken;
|
| - }
|
| -
|
| - int get length => _elements.length;
|
| -
|
| - @deprecated // Never intended for public use.
|
| - void set length(int value) {
|
| - throw new UnsupportedError("Cannot resize NodeList.");
|
| - }
|
| -
|
| - E operator [](int index) {
|
| - if (index < 0 || index >= _elements.length) {
|
| - throw new RangeError("Index: $index, Size: ${_elements.length}");
|
| - }
|
| - return _elements[index];
|
| - }
|
| -
|
| - void operator []=(int index, E node) {
|
| - if (index < 0 || index >= _elements.length) {
|
| - throw new RangeError("Index: $index, Size: ${_elements.length}");
|
| - }
|
| - owner._becomeParentOf(node);
|
| - _elements[index] = node;
|
| - }
|
| -
|
| - /**
|
| - * Use the given [visitor] to visit each of the nodes in this list.
|
| - */
|
| - accept(AstVisitor visitor) {
|
| - int length = _elements.length;
|
| - for (var i = 0; i < length; i++) {
|
| - _elements[i].accept(visitor);
|
| - }
|
| - }
|
| -
|
| - @override
|
| - void add(E node) {
|
| - insert(length, node);
|
| - }
|
| -
|
| - @override
|
| - bool addAll(Iterable<E> nodes) {
|
| - if (nodes != null && !nodes.isEmpty) {
|
| - _elements.addAll(nodes);
|
| - for (E node in nodes) {
|
| - owner._becomeParentOf(node);
|
| - }
|
| - return true;
|
| - }
|
| - return false;
|
| - }
|
| -
|
| - @override
|
| - void clear() {
|
| - _elements = <E>[];
|
| - }
|
| -
|
| - @override
|
| - void insert(int index, E node) {
|
| - int length = _elements.length;
|
| - if (index < 0 || index > length) {
|
| - throw new RangeError("Index: $index, Size: ${_elements.length}");
|
| - }
|
| - owner._becomeParentOf(node);
|
| - if (length == 0) {
|
| - _elements.add(node);
|
| - } else {
|
| - _elements.insert(index, node);
|
| - }
|
| - }
|
| -
|
| - @override
|
| - E removeAt(int index) {
|
| - if (index < 0 || index >= _elements.length) {
|
| - throw new RangeError("Index: $index, Size: ${_elements.length}");
|
| - }
|
| - E removedNode = _elements[index];
|
| - _elements.removeAt(index);
|
| - return removedNode;
|
| - }
|
| -
|
| - /**
|
| - * Create an empty list with the given [owner].
|
| - */
|
| - @deprecated // Use "new NodeList<E>(owner)"
|
| - static NodeList create(AstNode owner) => new NodeList(owner);
|
| -}
|
| -
|
| -/**
|
| - * An object used to locate the [AstNode] associated with a source range, given
|
| - * the AST structure built from the source. More specifically, they will return
|
| - * the [AstNode] with the shortest length whose source range completely
|
| - * encompasses the specified range.
|
| - */
|
| -class NodeLocator extends UnifyingAstVisitor<Object> {
|
| - /**
|
| - * The start offset of the range used to identify the node.
|
| - */
|
| - int _startOffset = 0;
|
| -
|
| - /**
|
| - * The end offset of the range used to identify the node.
|
| - */
|
| - int _endOffset = 0;
|
| -
|
| - /**
|
| - * The element that was found that corresponds to the given source range, or
|
| - * `null` if there is no such element.
|
| - */
|
| - AstNode _foundNode;
|
| -
|
| - /**
|
| - * Initialize a newly created locator to locate an [AstNode] by locating the
|
| - * node within an AST structure that corresponds to the given range of
|
| - * characters (between the [startOffset] and [endOffset] in the source.
|
| - */
|
| - NodeLocator(int startOffset, [int endOffset])
|
| - : this._startOffset = startOffset,
|
| - this._endOffset = endOffset == null ? startOffset : endOffset;
|
| -
|
| - /**
|
| - * Initialize a newly created locator to locate an [AstNode] by locating the
|
| - * node within an AST structure that corresponds to the given [offset] in the
|
| - * source.
|
| - */
|
| - @deprecated // Use new NodeLocator(offset)
|
| - NodeLocator.con1(int offset) : this(offset);
|
| -
|
| - /**
|
| - * Initialize a newly created locator to locate an [AstNode] by locating the
|
| - * node within an AST structure that corresponds to the given range of
|
| - * characters (between the [startOffset] and [endOffset] in the source.
|
| - */
|
| - @deprecated // Use new NodeLocator(startOffset, endOffset)
|
| - NodeLocator.con2(this._startOffset, this._endOffset);
|
| -
|
| - /**
|
| - * Return the node that was found that corresponds to the given source range
|
| - * or `null` if there is no such node.
|
| - */
|
| - AstNode get foundNode => _foundNode;
|
| -
|
| - /**
|
| - * Search within the given AST [node] for an identifier representing an
|
| - * element in the specified source range. Return the element that was found,
|
| - * or `null` if no element was found.
|
| - */
|
| - AstNode searchWithin(AstNode node) {
|
| - if (node == null) {
|
| - return null;
|
| - }
|
| - try {
|
| - node.accept(this);
|
| - } on NodeLocator_NodeFoundException {
|
| - // A node with the right source position was found.
|
| - } catch (exception, stackTrace) {
|
| - AnalysisEngine.instance.logger.logInformation(
|
| - "Unable to locate element at offset ($_startOffset - $_endOffset)",
|
| - new CaughtException(exception, stackTrace));
|
| - return null;
|
| - }
|
| - return _foundNode;
|
| - }
|
| -
|
| - @override
|
| - Object visitNode(AstNode node) {
|
| - Token beginToken = node.beginToken;
|
| - Token endToken = node.endToken;
|
| - // Don't include synthetic tokens.
|
| - while (endToken != beginToken) {
|
| - if (endToken.type == TokenType.EOF || !endToken.isSynthetic) {
|
| - break;
|
| - }
|
| - endToken = endToken.previous;
|
| - }
|
| - int end = endToken.end;
|
| - int start = node.offset;
|
| - if (end < _startOffset) {
|
| - return null;
|
| - }
|
| - if (start > _endOffset) {
|
| - return null;
|
| - }
|
| - try {
|
| - node.visitChildren(this);
|
| - } on NodeLocator_NodeFoundException {
|
| - rethrow;
|
| - } catch (exception, stackTrace) {
|
| - // Ignore the exception and proceed in order to visit the rest of the
|
| - // structure.
|
| - AnalysisEngine.instance.logger.logInformation(
|
| - "Exception caught while traversing an AST structure.",
|
| - new CaughtException(exception, stackTrace));
|
| - }
|
| - if (start <= _startOffset && _endOffset <= end) {
|
| - _foundNode = node;
|
| - throw new NodeLocator_NodeFoundException();
|
| - }
|
| - return null;
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * An exception used by [NodeLocator] to cancel visiting after a node has been
|
| - * found.
|
| - */
|
| -class NodeLocator_NodeFoundException extends RuntimeException {}
|
| -
|
| -/**
|
| - * An object that will replace one child node in an AST node with another node.
|
| - */
|
| -class NodeReplacer implements AstVisitor<bool> {
|
| - /**
|
| - * The node being replaced.
|
| - */
|
| - final AstNode _oldNode;
|
| -
|
| - /**
|
| - * The node that is replacing the old node.
|
| - */
|
| - final AstNode _newNode;
|
| -
|
| - /**
|
| - * Initialize a newly created node locator to replace the [_oldNode] with the
|
| - * [_newNode].
|
| - */
|
| - NodeReplacer(this._oldNode, this._newNode);
|
| -
|
| - @override
|
| - bool visitAdjacentStrings(AdjacentStrings node) {
|
| - if (_replaceInList(node.strings)) {
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - bool visitAnnotatedNode(AnnotatedNode node) {
|
| - if (identical(node.documentationComment, _oldNode)) {
|
| - node.documentationComment = _newNode as Comment;
|
| - return true;
|
| - } else if (_replaceInList(node.metadata)) {
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitAnnotation(Annotation node) {
|
| - if (identical(node.arguments, _oldNode)) {
|
| - node.arguments = _newNode as ArgumentList;
|
| - return true;
|
| - } else if (identical(node.constructorName, _oldNode)) {
|
| - node.constructorName = _newNode as SimpleIdentifier;
|
| - return true;
|
| - } else if (identical(node.name, _oldNode)) {
|
| - node.name = _newNode as Identifier;
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitArgumentList(ArgumentList node) {
|
| - if (_replaceInList(node.arguments)) {
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitAsExpression(AsExpression node) {
|
| - if (identical(node.expression, _oldNode)) {
|
| - node.expression = _newNode as Expression;
|
| - return true;
|
| - } else if (identical(node.type, _oldNode)) {
|
| - node.type = _newNode as TypeName;
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitAssertStatement(AssertStatement node) {
|
| - if (identical(node.condition, _oldNode)) {
|
| - node.condition = _newNode as Expression;
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitAssignmentExpression(AssignmentExpression node) {
|
| - if (identical(node.leftHandSide, _oldNode)) {
|
| - node.leftHandSide = _newNode as Expression;
|
| - return true;
|
| - } else if (identical(node.rightHandSide, _oldNode)) {
|
| - node.rightHandSide = _newNode as Expression;
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitAwaitExpression(AwaitExpression node) {
|
| - if (identical(node.expression, _oldNode)) {
|
| - node.expression = _newNode as Expression;
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitBinaryExpression(BinaryExpression node) {
|
| - if (identical(node.leftOperand, _oldNode)) {
|
| - node.leftOperand = _newNode as Expression;
|
| - return true;
|
| - } else if (identical(node.rightOperand, _oldNode)) {
|
| - node.rightOperand = _newNode as Expression;
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitBlock(Block node) {
|
| - if (_replaceInList(node.statements)) {
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitBlockFunctionBody(BlockFunctionBody node) {
|
| - if (identical(node.block, _oldNode)) {
|
| - node.block = _newNode as Block;
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitBooleanLiteral(BooleanLiteral node) => visitNode(node);
|
| -
|
| - @override
|
| - bool visitBreakStatement(BreakStatement node) {
|
| - if (identical(node.label, _oldNode)) {
|
| - node.label = _newNode as SimpleIdentifier;
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitCascadeExpression(CascadeExpression node) {
|
| - if (identical(node.target, _oldNode)) {
|
| - node.target = _newNode as Expression;
|
| - return true;
|
| - } else if (_replaceInList(node.cascadeSections)) {
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitCatchClause(CatchClause node) {
|
| - if (identical(node.exceptionType, _oldNode)) {
|
| - node.exceptionType = _newNode as TypeName;
|
| - return true;
|
| - } else if (identical(node.exceptionParameter, _oldNode)) {
|
| - node.exceptionParameter = _newNode as SimpleIdentifier;
|
| - return true;
|
| - } else if (identical(node.stackTraceParameter, _oldNode)) {
|
| - node.stackTraceParameter = _newNode as SimpleIdentifier;
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitClassDeclaration(ClassDeclaration node) {
|
| - if (identical(node.name, _oldNode)) {
|
| - node.name = _newNode as SimpleIdentifier;
|
| - return true;
|
| - } else if (identical(node.typeParameters, _oldNode)) {
|
| - node.typeParameters = _newNode as TypeParameterList;
|
| - return true;
|
| - } else if (identical(node.extendsClause, _oldNode)) {
|
| - node.extendsClause = _newNode as ExtendsClause;
|
| - return true;
|
| - } else if (identical(node.withClause, _oldNode)) {
|
| - node.withClause = _newNode as WithClause;
|
| - return true;
|
| - } else if (identical(node.implementsClause, _oldNode)) {
|
| - node.implementsClause = _newNode as ImplementsClause;
|
| - return true;
|
| - } else if (identical(node.nativeClause, _oldNode)) {
|
| - node.nativeClause = _newNode as NativeClause;
|
| - return true;
|
| - } else if (_replaceInList(node.members)) {
|
| - return true;
|
| - }
|
| - return visitAnnotatedNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitClassTypeAlias(ClassTypeAlias node) {
|
| - if (identical(node.name, _oldNode)) {
|
| - node.name = _newNode as SimpleIdentifier;
|
| - return true;
|
| - } else if (identical(node.typeParameters, _oldNode)) {
|
| - node.typeParameters = _newNode as TypeParameterList;
|
| - return true;
|
| - } else if (identical(node.superclass, _oldNode)) {
|
| - node.superclass = _newNode as TypeName;
|
| - return true;
|
| - } else if (identical(node.withClause, _oldNode)) {
|
| - node.withClause = _newNode as WithClause;
|
| - return true;
|
| - } else if (identical(node.implementsClause, _oldNode)) {
|
| - node.implementsClause = _newNode as ImplementsClause;
|
| - return true;
|
| - }
|
| - return visitAnnotatedNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitComment(Comment node) {
|
| - if (_replaceInList(node.references)) {
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitCommentReference(CommentReference node) {
|
| - if (identical(node.identifier, _oldNode)) {
|
| - node.identifier = _newNode as Identifier;
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitCompilationUnit(CompilationUnit node) {
|
| - if (identical(node.scriptTag, _oldNode)) {
|
| - node.scriptTag = _newNode as ScriptTag;
|
| - return true;
|
| - } else if (_replaceInList(node.directives)) {
|
| - return true;
|
| - } else if (_replaceInList(node.declarations)) {
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitConditionalExpression(ConditionalExpression node) {
|
| - if (identical(node.condition, _oldNode)) {
|
| - node.condition = _newNode as Expression;
|
| - return true;
|
| - } else if (identical(node.thenExpression, _oldNode)) {
|
| - node.thenExpression = _newNode as Expression;
|
| - return true;
|
| - } else if (identical(node.elseExpression, _oldNode)) {
|
| - node.elseExpression = _newNode as Expression;
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitConstructorDeclaration(ConstructorDeclaration node) {
|
| - if (identical(node.returnType, _oldNode)) {
|
| - node.returnType = _newNode as Identifier;
|
| - return true;
|
| - } else if (identical(node.name, _oldNode)) {
|
| - node.name = _newNode as SimpleIdentifier;
|
| - return true;
|
| - } else if (identical(node.parameters, _oldNode)) {
|
| - node.parameters = _newNode as FormalParameterList;
|
| - return true;
|
| - } else if (identical(node.redirectedConstructor, _oldNode)) {
|
| - node.redirectedConstructor = _newNode as ConstructorName;
|
| - return true;
|
| - } else if (identical(node.body, _oldNode)) {
|
| - node.body = _newNode as FunctionBody;
|
| - return true;
|
| - } else if (_replaceInList(node.initializers)) {
|
| - return true;
|
| - }
|
| - return visitAnnotatedNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
|
| - if (identical(node.fieldName, _oldNode)) {
|
| - node.fieldName = _newNode as SimpleIdentifier;
|
| - return true;
|
| - } else if (identical(node.expression, _oldNode)) {
|
| - node.expression = _newNode as Expression;
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitConstructorName(ConstructorName node) {
|
| - if (identical(node.type, _oldNode)) {
|
| - node.type = _newNode as TypeName;
|
| - return true;
|
| - } else if (identical(node.name, _oldNode)) {
|
| - node.name = _newNode as SimpleIdentifier;
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitContinueStatement(ContinueStatement node) {
|
| - if (identical(node.label, _oldNode)) {
|
| - node.label = _newNode as SimpleIdentifier;
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitDeclaredIdentifier(DeclaredIdentifier node) {
|
| - if (identical(node.type, _oldNode)) {
|
| - node.type = _newNode as TypeName;
|
| - return true;
|
| - } else if (identical(node.identifier, _oldNode)) {
|
| - node.identifier = _newNode as SimpleIdentifier;
|
| - return true;
|
| - }
|
| - return visitAnnotatedNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitDefaultFormalParameter(DefaultFormalParameter node) {
|
| - if (identical(node.parameter, _oldNode)) {
|
| - node.parameter = _newNode as NormalFormalParameter;
|
| - return true;
|
| - } else if (identical(node.defaultValue, _oldNode)) {
|
| - node.defaultValue = _newNode as Expression;
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitDoStatement(DoStatement node) {
|
| - if (identical(node.body, _oldNode)) {
|
| - node.body = _newNode as Statement;
|
| - return true;
|
| - } else if (identical(node.condition, _oldNode)) {
|
| - node.condition = _newNode as Expression;
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitDoubleLiteral(DoubleLiteral node) => visitNode(node);
|
| -
|
| - @override
|
| - bool visitEmptyFunctionBody(EmptyFunctionBody node) => visitNode(node);
|
| -
|
| - @override
|
| - bool visitEmptyStatement(EmptyStatement node) => visitNode(node);
|
| -
|
| - @override
|
| - bool visitEnumConstantDeclaration(EnumConstantDeclaration node) {
|
| - if (identical(node.name, _oldNode)) {
|
| - node.name = _newNode as SimpleIdentifier;
|
| - return true;
|
| - }
|
| - return visitAnnotatedNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitEnumDeclaration(EnumDeclaration node) {
|
| - if (identical(node.name, _oldNode)) {
|
| - node.name = _newNode as SimpleIdentifier;
|
| - return true;
|
| - } else if (_replaceInList(node.constants)) {
|
| - return true;
|
| - }
|
| - return visitAnnotatedNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitExportDirective(ExportDirective node) =>
|
| - visitNamespaceDirective(node);
|
| -
|
| - @override
|
| - bool visitExpressionFunctionBody(ExpressionFunctionBody node) {
|
| - if (identical(node.expression, _oldNode)) {
|
| - node.expression = _newNode as Expression;
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitExpressionStatement(ExpressionStatement node) {
|
| - if (identical(node.expression, _oldNode)) {
|
| - node.expression = _newNode as Expression;
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitExtendsClause(ExtendsClause node) {
|
| - if (identical(node.superclass, _oldNode)) {
|
| - node.superclass = _newNode as TypeName;
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitFieldDeclaration(FieldDeclaration node) {
|
| - if (identical(node.fields, _oldNode)) {
|
| - node.fields = _newNode as VariableDeclarationList;
|
| - return true;
|
| - }
|
| - return visitAnnotatedNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitFieldFormalParameter(FieldFormalParameter node) {
|
| - if (identical(node.type, _oldNode)) {
|
| - node.type = _newNode as TypeName;
|
| - return true;
|
| - } else if (identical(node.parameters, _oldNode)) {
|
| - node.parameters = _newNode as FormalParameterList;
|
| - return true;
|
| - }
|
| - return visitNormalFormalParameter(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitForEachStatement(ForEachStatement node) {
|
| - if (identical(node.loopVariable, _oldNode)) {
|
| - node.loopVariable = _newNode as DeclaredIdentifier;
|
| - return true;
|
| - } else if (identical(node.identifier, _oldNode)) {
|
| - node.identifier = _newNode as SimpleIdentifier;
|
| - return true;
|
| - } else if (identical(node.iterable, _oldNode)) {
|
| - node.iterable = _newNode as Expression;
|
| - return true;
|
| - } else if (identical(node.body, _oldNode)) {
|
| - node.body = _newNode as Statement;
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitFormalParameterList(FormalParameterList node) {
|
| - if (_replaceInList(node.parameters)) {
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitForStatement(ForStatement node) {
|
| - if (identical(node.variables, _oldNode)) {
|
| - node.variables = _newNode as VariableDeclarationList;
|
| - return true;
|
| - } else if (identical(node.initialization, _oldNode)) {
|
| - node.initialization = _newNode as Expression;
|
| - return true;
|
| - } else if (identical(node.condition, _oldNode)) {
|
| - node.condition = _newNode as Expression;
|
| - return true;
|
| - } else if (identical(node.body, _oldNode)) {
|
| - node.body = _newNode as Statement;
|
| - return true;
|
| - } else if (_replaceInList(node.updaters)) {
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitFunctionDeclaration(FunctionDeclaration node) {
|
| - if (identical(node.returnType, _oldNode)) {
|
| - node.returnType = _newNode as TypeName;
|
| - return true;
|
| - } else if (identical(node.name, _oldNode)) {
|
| - node.name = _newNode as SimpleIdentifier;
|
| - return true;
|
| - } else if (identical(node.functionExpression, _oldNode)) {
|
| - node.functionExpression = _newNode as FunctionExpression;
|
| - return true;
|
| - }
|
| - return visitAnnotatedNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitFunctionDeclarationStatement(FunctionDeclarationStatement node) {
|
| - if (identical(node.functionDeclaration, _oldNode)) {
|
| - node.functionDeclaration = _newNode as FunctionDeclaration;
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitFunctionExpression(FunctionExpression node) {
|
| - if (identical(node.parameters, _oldNode)) {
|
| - node.parameters = _newNode as FormalParameterList;
|
| - return true;
|
| - } else if (identical(node.body, _oldNode)) {
|
| - node.body = _newNode as FunctionBody;
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
|
| - if (identical(node.function, _oldNode)) {
|
| - node.function = _newNode as Expression;
|
| - return true;
|
| - } else if (identical(node.argumentList, _oldNode)) {
|
| - node.argumentList = _newNode as ArgumentList;
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitFunctionTypeAlias(FunctionTypeAlias node) {
|
| - if (identical(node.returnType, _oldNode)) {
|
| - node.returnType = _newNode as TypeName;
|
| - return true;
|
| - } else if (identical(node.name, _oldNode)) {
|
| - node.name = _newNode as SimpleIdentifier;
|
| - return true;
|
| - } else if (identical(node.typeParameters, _oldNode)) {
|
| - node.typeParameters = _newNode as TypeParameterList;
|
| - return true;
|
| - } else if (identical(node.parameters, _oldNode)) {
|
| - node.parameters = _newNode as FormalParameterList;
|
| - return true;
|
| - }
|
| - return visitAnnotatedNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
|
| - if (identical(node.returnType, _oldNode)) {
|
| - node.returnType = _newNode as TypeName;
|
| - return true;
|
| - } else if (identical(node.parameters, _oldNode)) {
|
| - node.parameters = _newNode as FormalParameterList;
|
| - return true;
|
| - }
|
| - return visitNormalFormalParameter(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitHideCombinator(HideCombinator node) {
|
| - if (_replaceInList(node.hiddenNames)) {
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitIfStatement(IfStatement node) {
|
| - if (identical(node.condition, _oldNode)) {
|
| - node.condition = _newNode as Expression;
|
| - return true;
|
| - } else if (identical(node.thenStatement, _oldNode)) {
|
| - node.thenStatement = _newNode as Statement;
|
| - return true;
|
| - } else if (identical(node.elseStatement, _oldNode)) {
|
| - node.elseStatement = _newNode as Statement;
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitImplementsClause(ImplementsClause node) {
|
| - if (_replaceInList(node.interfaces)) {
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitImportDirective(ImportDirective node) {
|
| - if (identical(node.prefix, _oldNode)) {
|
| - node.prefix = _newNode as SimpleIdentifier;
|
| - return true;
|
| - }
|
| - return visitNamespaceDirective(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitIndexExpression(IndexExpression node) {
|
| - if (identical(node.target, _oldNode)) {
|
| - node.target = _newNode as Expression;
|
| - return true;
|
| - } else if (identical(node.index, _oldNode)) {
|
| - node.index = _newNode as Expression;
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitInstanceCreationExpression(InstanceCreationExpression node) {
|
| - if (identical(node.constructorName, _oldNode)) {
|
| - node.constructorName = _newNode as ConstructorName;
|
| - return true;
|
| - } else if (identical(node.argumentList, _oldNode)) {
|
| - node.argumentList = _newNode as ArgumentList;
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitIntegerLiteral(IntegerLiteral node) => visitNode(node);
|
| -
|
| - @override
|
| - bool visitInterpolationExpression(InterpolationExpression node) {
|
| - if (identical(node.expression, _oldNode)) {
|
| - node.expression = _newNode as Expression;
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitInterpolationString(InterpolationString node) => visitNode(node);
|
| -
|
| - @override
|
| - bool visitIsExpression(IsExpression node) {
|
| - if (identical(node.expression, _oldNode)) {
|
| - node.expression = _newNode as Expression;
|
| - return true;
|
| - } else if (identical(node.type, _oldNode)) {
|
| - node.type = _newNode as TypeName;
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitLabel(Label node) {
|
| - if (identical(node.label, _oldNode)) {
|
| - node.label = _newNode as SimpleIdentifier;
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitLabeledStatement(LabeledStatement node) {
|
| - if (identical(node.statement, _oldNode)) {
|
| - node.statement = _newNode as Statement;
|
| - return true;
|
| - } else if (_replaceInList(node.labels)) {
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitLibraryDirective(LibraryDirective node) {
|
| - if (identical(node.name, _oldNode)) {
|
| - node.name = _newNode as LibraryIdentifier;
|
| - return true;
|
| - }
|
| - return visitAnnotatedNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitLibraryIdentifier(LibraryIdentifier node) {
|
| - if (_replaceInList(node.components)) {
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitListLiteral(ListLiteral node) {
|
| - if (_replaceInList(node.elements)) {
|
| - return true;
|
| - }
|
| - return visitTypedLiteral(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitMapLiteral(MapLiteral node) {
|
| - if (_replaceInList(node.entries)) {
|
| - return true;
|
| - }
|
| - return visitTypedLiteral(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitMapLiteralEntry(MapLiteralEntry node) {
|
| - if (identical(node.key, _oldNode)) {
|
| - node.key = _newNode as Expression;
|
| - return true;
|
| - } else if (identical(node.value, _oldNode)) {
|
| - node.value = _newNode as Expression;
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitMethodDeclaration(MethodDeclaration node) {
|
| - if (identical(node.returnType, _oldNode)) {
|
| - node.returnType = _newNode as TypeName;
|
| - return true;
|
| - } else if (identical(node.name, _oldNode)) {
|
| - node.name = _newNode as SimpleIdentifier;
|
| - return true;
|
| - } else if (identical(node.parameters, _oldNode)) {
|
| - node.parameters = _newNode as FormalParameterList;
|
| - return true;
|
| - } else if (identical(node.body, _oldNode)) {
|
| - node.body = _newNode as FunctionBody;
|
| - return true;
|
| - }
|
| - return visitAnnotatedNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitMethodInvocation(MethodInvocation node) {
|
| - if (identical(node.target, _oldNode)) {
|
| - node.target = _newNode as Expression;
|
| - return true;
|
| - } else if (identical(node.methodName, _oldNode)) {
|
| - node.methodName = _newNode as SimpleIdentifier;
|
| - return true;
|
| - } else if (identical(node.argumentList, _oldNode)) {
|
| - node.argumentList = _newNode as ArgumentList;
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitNamedExpression(NamedExpression node) {
|
| - if (identical(node.name, _oldNode)) {
|
| - node.name = _newNode as Label;
|
| - return true;
|
| - } else if (identical(node.expression, _oldNode)) {
|
| - node.expression = _newNode as Expression;
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - bool visitNamespaceDirective(NamespaceDirective node) {
|
| - if (_replaceInList(node.combinators)) {
|
| - return true;
|
| - }
|
| - return visitUriBasedDirective(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitNativeClause(NativeClause node) {
|
| - if (identical(node.name, _oldNode)) {
|
| - node.name = _newNode as StringLiteral;
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitNativeFunctionBody(NativeFunctionBody node) {
|
| - if (identical(node.stringLiteral, _oldNode)) {
|
| - node.stringLiteral = _newNode as StringLiteral;
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - bool visitNode(AstNode node) {
|
| - throw new IllegalArgumentException(
|
| - "The old node is not a child of it's parent");
|
| - }
|
| -
|
| - bool visitNormalFormalParameter(NormalFormalParameter node) {
|
| - if (identical(node.documentationComment, _oldNode)) {
|
| - node.documentationComment = _newNode as Comment;
|
| - return true;
|
| - } else if (identical(node.identifier, _oldNode)) {
|
| - node.identifier = _newNode as SimpleIdentifier;
|
| - return true;
|
| - } else if (_replaceInList(node.metadata)) {
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitNullLiteral(NullLiteral node) => visitNode(node);
|
| -
|
| - @override
|
| - bool visitParenthesizedExpression(ParenthesizedExpression node) {
|
| - if (identical(node.expression, _oldNode)) {
|
| - node.expression = _newNode as Expression;
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitPartDirective(PartDirective node) => visitUriBasedDirective(node);
|
| -
|
| - @override
|
| - bool visitPartOfDirective(PartOfDirective node) {
|
| - if (identical(node.libraryName, _oldNode)) {
|
| - node.libraryName = _newNode as LibraryIdentifier;
|
| - return true;
|
| - }
|
| - return visitAnnotatedNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitPostfixExpression(PostfixExpression node) {
|
| - if (identical(node.operand, _oldNode)) {
|
| - node.operand = _newNode as Expression;
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitPrefixedIdentifier(PrefixedIdentifier node) {
|
| - if (identical(node.prefix, _oldNode)) {
|
| - node.prefix = _newNode as SimpleIdentifier;
|
| - return true;
|
| - } else if (identical(node.identifier, _oldNode)) {
|
| - node.identifier = _newNode as SimpleIdentifier;
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitPrefixExpression(PrefixExpression node) {
|
| - if (identical(node.operand, _oldNode)) {
|
| - node.operand = _newNode as Expression;
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitPropertyAccess(PropertyAccess node) {
|
| - if (identical(node.target, _oldNode)) {
|
| - node.target = _newNode as Expression;
|
| - return true;
|
| - } else if (identical(node.propertyName, _oldNode)) {
|
| - node.propertyName = _newNode as SimpleIdentifier;
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitRedirectingConstructorInvocation(
|
| - RedirectingConstructorInvocation node) {
|
| - if (identical(node.constructorName, _oldNode)) {
|
| - node.constructorName = _newNode as SimpleIdentifier;
|
| - return true;
|
| - } else if (identical(node.argumentList, _oldNode)) {
|
| - node.argumentList = _newNode as ArgumentList;
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitRethrowExpression(RethrowExpression node) => visitNode(node);
|
| -
|
| - @override
|
| - bool visitReturnStatement(ReturnStatement node) {
|
| - if (identical(node.expression, _oldNode)) {
|
| - node.expression = _newNode as Expression;
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitScriptTag(ScriptTag scriptTag) => visitNode(scriptTag);
|
| -
|
| - @override
|
| - bool visitShowCombinator(ShowCombinator node) {
|
| - if (_replaceInList(node.shownNames)) {
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitSimpleFormalParameter(SimpleFormalParameter node) {
|
| - if (identical(node.type, _oldNode)) {
|
| - node.type = _newNode as TypeName;
|
| - return true;
|
| - }
|
| - return visitNormalFormalParameter(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitSimpleIdentifier(SimpleIdentifier node) => visitNode(node);
|
| -
|
| - @override
|
| - bool visitSimpleStringLiteral(SimpleStringLiteral node) => visitNode(node);
|
| -
|
| - @override
|
| - bool visitStringInterpolation(StringInterpolation node) {
|
| - if (_replaceInList(node.elements)) {
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitSuperConstructorInvocation(SuperConstructorInvocation node) {
|
| - if (identical(node.constructorName, _oldNode)) {
|
| - node.constructorName = _newNode as SimpleIdentifier;
|
| - return true;
|
| - } else if (identical(node.argumentList, _oldNode)) {
|
| - node.argumentList = _newNode as ArgumentList;
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitSuperExpression(SuperExpression node) => visitNode(node);
|
| -
|
| - @override
|
| - bool visitSwitchCase(SwitchCase node) {
|
| - if (identical(node.expression, _oldNode)) {
|
| - node.expression = _newNode as Expression;
|
| - return true;
|
| - }
|
| - return visitSwitchMember(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitSwitchDefault(SwitchDefault node) => visitSwitchMember(node);
|
| -
|
| - bool visitSwitchMember(SwitchMember node) {
|
| - if (_replaceInList(node.labels)) {
|
| - return true;
|
| - } else if (_replaceInList(node.statements)) {
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitSwitchStatement(SwitchStatement node) {
|
| - if (identical(node.expression, _oldNode)) {
|
| - node.expression = _newNode as Expression;
|
| - return true;
|
| - } else if (_replaceInList(node.members)) {
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitSymbolLiteral(SymbolLiteral node) => visitNode(node);
|
| -
|
| - @override
|
| - bool visitThisExpression(ThisExpression node) => visitNode(node);
|
| -
|
| - @override
|
| - bool visitThrowExpression(ThrowExpression node) {
|
| - if (identical(node.expression, _oldNode)) {
|
| - node.expression = _newNode as Expression;
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
|
| - if (identical(node.variables, _oldNode)) {
|
| - node.variables = _newNode as VariableDeclarationList;
|
| - return true;
|
| - }
|
| - return visitAnnotatedNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitTryStatement(TryStatement node) {
|
| - if (identical(node.body, _oldNode)) {
|
| - node.body = _newNode as Block;
|
| - return true;
|
| - } else if (identical(node.finallyBlock, _oldNode)) {
|
| - node.finallyBlock = _newNode as Block;
|
| - return true;
|
| - } else if (_replaceInList(node.catchClauses)) {
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitTypeArgumentList(TypeArgumentList node) {
|
| - if (_replaceInList(node.arguments)) {
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - bool visitTypedLiteral(TypedLiteral node) {
|
| - if (identical(node.typeArguments, _oldNode)) {
|
| - node.typeArguments = _newNode as TypeArgumentList;
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitTypeName(TypeName node) {
|
| - if (identical(node.name, _oldNode)) {
|
| - node.name = _newNode as Identifier;
|
| - return true;
|
| - } else if (identical(node.typeArguments, _oldNode)) {
|
| - node.typeArguments = _newNode as TypeArgumentList;
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitTypeParameter(TypeParameter node) {
|
| - if (identical(node.name, _oldNode)) {
|
| - node.name = _newNode as SimpleIdentifier;
|
| - return true;
|
| - } else if (identical(node.bound, _oldNode)) {
|
| - node.bound = _newNode as TypeName;
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitTypeParameterList(TypeParameterList node) {
|
| - if (_replaceInList(node.typeParameters)) {
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - bool visitUriBasedDirective(UriBasedDirective node) {
|
| - if (identical(node.uri, _oldNode)) {
|
| - node.uri = _newNode as StringLiteral;
|
| - return true;
|
| - }
|
| - return visitAnnotatedNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitVariableDeclaration(VariableDeclaration node) {
|
| - if (identical(node.name, _oldNode)) {
|
| - node.name = _newNode as SimpleIdentifier;
|
| - return true;
|
| - } else if (identical(node.initializer, _oldNode)) {
|
| - node.initializer = _newNode as Expression;
|
| - return true;
|
| - }
|
| - return visitAnnotatedNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitVariableDeclarationList(VariableDeclarationList node) {
|
| - if (identical(node.type, _oldNode)) {
|
| - node.type = _newNode as TypeName;
|
| - return true;
|
| - } else if (_replaceInList(node.variables)) {
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitVariableDeclarationStatement(VariableDeclarationStatement node) {
|
| - if (identical(node.variables, _oldNode)) {
|
| - node.variables = _newNode as VariableDeclarationList;
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitWhileStatement(WhileStatement node) {
|
| - if (identical(node.condition, _oldNode)) {
|
| - node.condition = _newNode as Expression;
|
| - return true;
|
| - } else if (identical(node.body, _oldNode)) {
|
| - node.body = _newNode as Statement;
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitWithClause(WithClause node) {
|
| - if (_replaceInList(node.mixinTypes)) {
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - @override
|
| - bool visitYieldStatement(YieldStatement node) {
|
| - if (identical(node.expression, _oldNode)) {
|
| - node.expression = _newNode as Expression;
|
| - return true;
|
| - }
|
| - return visitNode(node);
|
| - }
|
| -
|
| - bool _replaceInList(NodeList list) {
|
| - int count = list.length;
|
| - for (int i = 0; i < count; i++) {
|
| - if (identical(_oldNode, list[i])) {
|
| - list[i] = _newNode;
|
| - return true;
|
| - }
|
| - }
|
| - return false;
|
| - }
|
| -
|
| - /**
|
| - * Replace the [oldNode] with the [newNode] in the AST structure containing
|
| - * the old node. Return `true` if the replacement was successful.
|
| - *
|
| - * Throws an [IllegalArgumentException] if either node is `null`, if the old
|
| - * node does not have a parent node, or if the AST structure has been
|
| - * corrupted.
|
| - */
|
| - static bool replace(AstNode oldNode, AstNode newNode) {
|
| - if (oldNode == null || newNode == null) {
|
| - throw new IllegalArgumentException(
|
| - "The old and new nodes must be non-null");
|
| - } else if (identical(oldNode, newNode)) {
|
| - return true;
|
| - }
|
| - AstNode parent = oldNode.parent;
|
| - if (parent == null) {
|
| - throw new IllegalArgumentException(
|
| - "The old node is not a child of another node");
|
| - }
|
| - NodeReplacer replacer = new NodeReplacer(oldNode, newNode);
|
| - return parent.accept(replacer);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A formal parameter that is required (is not optional).
|
| - *
|
| - * > normalFormalParameter ::=
|
| - * > [FunctionTypedFormalParameter]
|
| - * > | [FieldFormalParameter]
|
| - * > | [SimpleFormalParameter]
|
| - */
|
| -abstract class NormalFormalParameter extends FormalParameter {
|
| - /**
|
| - * The documentation comment associated with this parameter, or `null` if this
|
| - * parameter does not have a documentation comment associated with it.
|
| - */
|
| - Comment _comment;
|
| -
|
| - /**
|
| - * The annotations associated with this parameter.
|
| - */
|
| - NodeList<Annotation> _metadata;
|
| -
|
| - /**
|
| - * The name of the parameter being declared.
|
| - */
|
| - SimpleIdentifier _identifier;
|
| -
|
| - /**
|
| - * Initialize a newly created formal parameter. Either or both of the
|
| - * [comment] and [metadata] can be `null` if the parameter does not have the
|
| - * corresponding attribute.
|
| - */
|
| - NormalFormalParameter(
|
| - Comment comment, List<Annotation> metadata, SimpleIdentifier identifier) {
|
| - _comment = _becomeParentOf(comment);
|
| - _metadata = new NodeList<Annotation>(this, metadata);
|
| - _identifier = _becomeParentOf(identifier);
|
| - }
|
| -
|
| - /**
|
| - * Return the documentation comment associated with this parameter, or `null`
|
| - * if this parameter does not have a documentation comment associated with it.
|
| - */
|
| - Comment get documentationComment => _comment;
|
| -
|
| - /**
|
| - * Set the documentation comment associated with this parameter to the given
|
| - * [comment].
|
| - */
|
| - void set documentationComment(Comment comment) {
|
| - _comment = _becomeParentOf(comment);
|
| - }
|
| -
|
| - @override
|
| - SimpleIdentifier get identifier => _identifier;
|
| -
|
| - /**
|
| - * Set the name of the parameter being declared to the given [identifier].
|
| - */
|
| - void set identifier(SimpleIdentifier identifier) {
|
| - _identifier = _becomeParentOf(identifier);
|
| - }
|
| -
|
| - @override
|
| - ParameterKind get kind {
|
| - AstNode parent = this.parent;
|
| - if (parent is DefaultFormalParameter) {
|
| - return parent.kind;
|
| - }
|
| - return ParameterKind.REQUIRED;
|
| - }
|
| -
|
| - /**
|
| - * Return the annotations associated with this parameter.
|
| - */
|
| - NodeList<Annotation> get metadata => _metadata;
|
| -
|
| - /**
|
| - * Set the metadata associated with this node to the given [metadata].
|
| - */
|
| - void set metadata(List<Annotation> metadata) {
|
| - _metadata.clear();
|
| - _metadata.addAll(metadata);
|
| - }
|
| -
|
| - /**
|
| - * Return a list containing the comment and annotations associated with this
|
| - * parameter, sorted in lexical order.
|
| - */
|
| - List<AstNode> get sortedCommentAndAnnotations {
|
| - return <AstNode>[]
|
| - ..add(_comment)
|
| - ..addAll(_metadata)
|
| - ..sort(AstNode.LEXICAL_ORDER);
|
| - }
|
| -
|
| - ChildEntities get _childEntities {
|
| - ChildEntities result = new ChildEntities();
|
| - if (_commentIsBeforeAnnotations()) {
|
| - result
|
| - ..add(_comment)
|
| - ..addAll(_metadata);
|
| - } else {
|
| - result.addAll(sortedCommentAndAnnotations);
|
| - }
|
| - return result;
|
| - }
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - //
|
| - // Note that subclasses are responsible for visiting the identifier because
|
| - // they often need to visit other nodes before visiting the identifier.
|
| - //
|
| - if (_commentIsBeforeAnnotations()) {
|
| - _safelyVisitChild(_comment, visitor);
|
| - _metadata.accept(visitor);
|
| - } else {
|
| - for (AstNode child in sortedCommentAndAnnotations) {
|
| - child.accept(visitor);
|
| - }
|
| - }
|
| - }
|
| -
|
| - /**
|
| - * Return `true` if the comment is lexically before any annotations.
|
| - */
|
| - bool _commentIsBeforeAnnotations() {
|
| - if (_comment == null || _metadata.isEmpty) {
|
| - return true;
|
| - }
|
| - Annotation firstAnnotation = _metadata[0];
|
| - return _comment.offset < firstAnnotation.offset;
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A null literal expression.
|
| - *
|
| - * > nullLiteral ::=
|
| - * > 'null'
|
| - */
|
| -class NullLiteral extends Literal {
|
| - /**
|
| - * The token representing the literal.
|
| - */
|
| - Token literal;
|
| -
|
| - /**
|
| - * Initialize a newly created null literal.
|
| - */
|
| - NullLiteral(this.literal);
|
| -
|
| - @override
|
| - Token get beginToken => literal;
|
| -
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()..add(literal);
|
| -
|
| - @override
|
| - Token get endToken => literal;
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitNullLiteral(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - // There are no children to visit.
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A parenthesized expression.
|
| - *
|
| - * > parenthesizedExpression ::=
|
| - * > '(' [Expression] ')'
|
| - */
|
| -class ParenthesizedExpression extends Expression {
|
| - /**
|
| - * The left parenthesis.
|
| - */
|
| - Token leftParenthesis;
|
| -
|
| - /**
|
| - * The expression within the parentheses.
|
| - */
|
| - Expression _expression;
|
| -
|
| - /**
|
| - * The right parenthesis.
|
| - */
|
| - Token rightParenthesis;
|
| -
|
| - /**
|
| - * Initialize a newly created parenthesized expression.
|
| - */
|
| - ParenthesizedExpression(
|
| - this.leftParenthesis, Expression expression, this.rightParenthesis) {
|
| - _expression = _becomeParentOf(expression);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => leftParenthesis;
|
| -
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()
|
| - ..add(leftParenthesis)
|
| - ..add(_expression)
|
| - ..add(rightParenthesis);
|
| -
|
| - @override
|
| - Token get endToken => rightParenthesis;
|
| -
|
| - /**
|
| - * Return the expression within the parentheses.
|
| - */
|
| - Expression get expression => _expression;
|
| -
|
| - /**
|
| - * Set the expression within the parentheses to the given [expression].
|
| - */
|
| - void set expression(Expression expression) {
|
| - _expression = _becomeParentOf(expression);
|
| - }
|
| -
|
| - @override
|
| - int get precedence => 15;
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitParenthesizedExpression(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_expression, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A part directive.
|
| - *
|
| - * > partDirective ::=
|
| - * > [Annotation] 'part' [StringLiteral] ';'
|
| - */
|
| -class PartDirective extends UriBasedDirective {
|
| - /**
|
| - * The token representing the 'part' keyword.
|
| - */
|
| - Token partKeyword;
|
| -
|
| - /**
|
| - * The semicolon terminating the directive.
|
| - */
|
| - Token semicolon;
|
| -
|
| - /**
|
| - * Initialize a newly created part directive. Either or both of the [comment]
|
| - * and [metadata] can be `null` if the directive does not have the
|
| - * corresponding attribute.
|
| - */
|
| - PartDirective(Comment comment, List<Annotation> metadata, this.partKeyword,
|
| - StringLiteral partUri, this.semicolon)
|
| - : super(comment, metadata, partUri);
|
| -
|
| - @override
|
| - Iterable get childEntities =>
|
| - super._childEntities..add(partKeyword)..add(_uri)..add(semicolon);
|
| -
|
| - @override
|
| - Token get endToken => semicolon;
|
| -
|
| - @override
|
| - Token get firstTokenAfterCommentAndMetadata => partKeyword;
|
| -
|
| - @override
|
| - Token get keyword => partKeyword;
|
| -
|
| - /**
|
| - * Return the token representing the 'part' token.
|
| - */
|
| - @deprecated // Use "this.partKeyword"
|
| - Token get partToken => partKeyword;
|
| -
|
| - /**
|
| - * Set the token representing the 'part' token to the given [token].
|
| - */
|
| - @deprecated // Use "this.partKeyword"
|
| - set partToken(Token token) {
|
| - partKeyword = token;
|
| - }
|
| -
|
| - @override
|
| - CompilationUnitElement get uriElement => element as CompilationUnitElement;
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitPartDirective(this);
|
| -}
|
| -
|
| -/**
|
| - * A part-of directive.
|
| - *
|
| - * > partOfDirective ::=
|
| - * > [Annotation] 'part' 'of' [Identifier] ';'
|
| - */
|
| -class PartOfDirective extends Directive {
|
| - /**
|
| - * The token representing the 'part' keyword.
|
| - */
|
| - Token partKeyword;
|
| -
|
| - /**
|
| - * The token representing the 'of' keyword.
|
| - */
|
| - Token ofKeyword;
|
| -
|
| - /**
|
| - * The name of the library that the containing compilation unit is part of.
|
| - */
|
| - LibraryIdentifier _libraryName;
|
| -
|
| - /**
|
| - * The semicolon terminating the directive.
|
| - */
|
| - Token semicolon;
|
| -
|
| - /**
|
| - * Initialize a newly created part-of directive. Either or both of the
|
| - * [comment] and [metadata] can be `null` if the directive does not have the
|
| - * corresponding attribute.
|
| - */
|
| - PartOfDirective(Comment comment, List<Annotation> metadata, this.partKeyword,
|
| - this.ofKeyword, LibraryIdentifier libraryName, this.semicolon)
|
| - : super(comment, metadata) {
|
| - _libraryName = _becomeParentOf(libraryName);
|
| - }
|
| -
|
| - @override
|
| - Iterable get childEntities => super._childEntities
|
| - ..add(partKeyword)
|
| - ..add(ofKeyword)
|
| - ..add(_libraryName)
|
| - ..add(semicolon);
|
| -
|
| - @override
|
| - Token get endToken => semicolon;
|
| -
|
| - @override
|
| - Token get firstTokenAfterCommentAndMetadata => partKeyword;
|
| -
|
| - @override
|
| - Token get keyword => partKeyword;
|
| -
|
| - /**
|
| - * Return the name of the library that the containing compilation unit is part
|
| - * of.
|
| - */
|
| - LibraryIdentifier get libraryName => _libraryName;
|
| -
|
| - /**
|
| - * Set the name of the library that the containing compilation unit is part of
|
| - * to the given [libraryName].
|
| - */
|
| - void set libraryName(LibraryIdentifier libraryName) {
|
| - _libraryName = _becomeParentOf(libraryName);
|
| - }
|
| -
|
| - /**
|
| - * Return the token representing the 'of' token.
|
| - */
|
| - @deprecated // Use "this.ofKeyword"
|
| - Token get ofToken => ofKeyword;
|
| -
|
| - /**
|
| - * Set the token representing the 'of' token to the given [token].
|
| - */
|
| - @deprecated // Use "this.ofKeyword"
|
| - set ofToken(Token token) {
|
| - ofKeyword = token;
|
| - }
|
| -
|
| - /**
|
| - * Return the token representing the 'part' token.
|
| - */
|
| - @deprecated // Use "this.partKeyword"
|
| - Token get partToken => partKeyword;
|
| -
|
| - /**
|
| - * Set the token representing the 'part' token to the given [token].
|
| - */
|
| - @deprecated // Use "this.partKeyword"
|
| - set partToken(Token token) {
|
| - partKeyword = token;
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitPartOfDirective(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - super.visitChildren(visitor);
|
| - _safelyVisitChild(_libraryName, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A postfix unary expression.
|
| - *
|
| - * > postfixExpression ::=
|
| - * > [Expression] [Token]
|
| - */
|
| -class PostfixExpression extends Expression {
|
| - /**
|
| - * The expression computing the operand for the operator.
|
| - */
|
| - Expression _operand;
|
| -
|
| - /**
|
| - * The postfix operator being applied to the operand.
|
| - */
|
| - Token operator;
|
| -
|
| - /**
|
| - * The element associated with this the operator based on the propagated type
|
| - * of the operand, or `null` if the AST structure has not been resolved, if
|
| - * the operator is not user definable, or if the operator could not be
|
| - * resolved.
|
| - */
|
| - MethodElement propagatedElement;
|
| -
|
| - /**
|
| - * The element associated with the operator based on the static type of the
|
| - * operand, or `null` if the AST structure has not been resolved, if the
|
| - * operator is not user definable, or if the operator could not be resolved.
|
| - */
|
| - MethodElement staticElement;
|
| -
|
| - /**
|
| - * Initialize a newly created postfix expression.
|
| - */
|
| - PostfixExpression(Expression operand, this.operator) {
|
| - _operand = _becomeParentOf(operand);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => _operand.beginToken;
|
| -
|
| - /**
|
| - * Return the best element available for this operator. If resolution was able
|
| - * to find a better element based on type propagation, that element will be
|
| - * returned. Otherwise, the element found using the result of static analysis
|
| - * will be returned. If resolution has not been performed, then `null` will be
|
| - * returned.
|
| - */
|
| - MethodElement get bestElement {
|
| - MethodElement element = propagatedElement;
|
| - if (element == null) {
|
| - element = staticElement;
|
| - }
|
| - return element;
|
| - }
|
| -
|
| - @override
|
| - Iterable get childEntities =>
|
| - new ChildEntities()..add(_operand)..add(operator);
|
| -
|
| - @override
|
| - Token get endToken => operator;
|
| -
|
| - /**
|
| - * Return the expression computing the operand for the operator.
|
| - */
|
| - Expression get operand => _operand;
|
| -
|
| - /**
|
| - * Set the expression computing the operand for the operator to the given
|
| - * [expression].
|
| - */
|
| - void set operand(Expression expression) {
|
| - _operand = _becomeParentOf(expression);
|
| - }
|
| -
|
| - @override
|
| - int get precedence => 15;
|
| -
|
| - /**
|
| - * If the AST structure has been resolved, and the function being invoked is
|
| - * known based on propagated type information, then return the parameter
|
| - * element representing the parameter to which the value of the operand will
|
| - * be bound. Otherwise, return `null`.
|
| - */
|
| - @deprecated // Use "expression.propagatedParameterElement"
|
| - ParameterElement get propagatedParameterElementForOperand {
|
| - return _propagatedParameterElementForOperand;
|
| - }
|
| -
|
| - /**
|
| - * If the AST structure has been resolved, and the function being invoked is
|
| - * known based on static type information, then return the parameter element
|
| - * representing the parameter to which the value of the operand will be bound.
|
| - * Otherwise, return `null`.
|
| - */
|
| - @deprecated // Use "expression.propagatedParameterElement"
|
| - ParameterElement get staticParameterElementForOperand {
|
| - return _staticParameterElementForOperand;
|
| - }
|
| -
|
| - /**
|
| - * If the AST structure has been resolved, and the function being invoked is
|
| - * known based on propagated type information, then return the parameter
|
| - * element representing the parameter to which the value of the operand will
|
| - * be bound. Otherwise, return `null`.
|
| - */
|
| - ParameterElement get _propagatedParameterElementForOperand {
|
| - if (propagatedElement == null) {
|
| - return null;
|
| - }
|
| - List<ParameterElement> parameters = propagatedElement.parameters;
|
| - if (parameters.length < 1) {
|
| - return null;
|
| - }
|
| - return parameters[0];
|
| - }
|
| -
|
| - /**
|
| - * If the AST structure has been resolved, and the function being invoked is
|
| - * known based on static type information, then return the parameter element
|
| - * representing the parameter to which the value of the operand will be bound.
|
| - * Otherwise, return `null`.
|
| - */
|
| - ParameterElement get _staticParameterElementForOperand {
|
| - if (staticElement == null) {
|
| - return null;
|
| - }
|
| - List<ParameterElement> parameters = staticElement.parameters;
|
| - if (parameters.length < 1) {
|
| - return null;
|
| - }
|
| - return parameters[0];
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitPostfixExpression(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_operand, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * An identifier that is prefixed or an access to an object property where the
|
| - * target of the property access is a simple identifier.
|
| - *
|
| - * > prefixedIdentifier ::=
|
| - * > [SimpleIdentifier] '.' [SimpleIdentifier]
|
| - */
|
| -class PrefixedIdentifier extends Identifier {
|
| - /**
|
| - * The prefix associated with the library in which the identifier is defined.
|
| - */
|
| - SimpleIdentifier _prefix;
|
| -
|
| - /**
|
| - * The period used to separate the prefix from the identifier.
|
| - */
|
| - Token period;
|
| -
|
| - /**
|
| - * The identifier being prefixed.
|
| - */
|
| - SimpleIdentifier _identifier;
|
| -
|
| - /**
|
| - * Initialize a newly created prefixed identifier.
|
| - */
|
| - PrefixedIdentifier(
|
| - SimpleIdentifier prefix, this.period, SimpleIdentifier identifier) {
|
| - _prefix = _becomeParentOf(prefix);
|
| - _identifier = _becomeParentOf(identifier);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => _prefix.beginToken;
|
| -
|
| - @override
|
| - Element get bestElement {
|
| - if (_identifier == null) {
|
| - return null;
|
| - }
|
| - return _identifier.bestElement;
|
| - }
|
| -
|
| - @override
|
| - Iterable get childEntities =>
|
| - new ChildEntities()..add(_prefix)..add(period)..add(_identifier);
|
| -
|
| - @override
|
| - Token get endToken => _identifier.endToken;
|
| -
|
| - /**
|
| - * Return the identifier being prefixed.
|
| - */
|
| - SimpleIdentifier get identifier => _identifier;
|
| -
|
| - /**
|
| - * Set the identifier being prefixed to the given [identifier].
|
| - */
|
| - void set identifier(SimpleIdentifier identifier) {
|
| - _identifier = _becomeParentOf(identifier);
|
| - }
|
| -
|
| - /**
|
| - * Return `true` if this type is a deferred type. If the AST structure has not
|
| - * been resolved, then return `false`.
|
| - *
|
| - * 15.1 Static Types: A type <i>T</i> is deferred iff it is of the form
|
| - * </i>p.T</i> where <i>p</i> is a deferred prefix.
|
| - */
|
| - bool get isDeferred {
|
| - Element element = _prefix.staticElement;
|
| - if (element is! PrefixElement) {
|
| - return false;
|
| - }
|
| - PrefixElement prefixElement = element as PrefixElement;
|
| - List<ImportElement> imports =
|
| - prefixElement.enclosingElement.getImportsWithPrefix(prefixElement);
|
| - if (imports.length != 1) {
|
| - return false;
|
| - }
|
| - return imports[0].isDeferred;
|
| - }
|
| -
|
| - @override
|
| - String get name => "${_prefix.name}.${_identifier.name}";
|
| -
|
| - @override
|
| - int get precedence => 15;
|
| -
|
| - /**
|
| - * Return the prefix associated with the library in which the identifier is
|
| - * defined.
|
| - */
|
| - SimpleIdentifier get prefix => _prefix;
|
| -
|
| - /**
|
| - * Set the prefix associated with the library in which the identifier is
|
| - * defined to the given [identifier].
|
| - */
|
| - void set prefix(SimpleIdentifier identifier) {
|
| - _prefix = _becomeParentOf(identifier);
|
| - }
|
| -
|
| - @override
|
| - Element get propagatedElement {
|
| - if (_identifier == null) {
|
| - return null;
|
| - }
|
| - return _identifier.propagatedElement;
|
| - }
|
| -
|
| - @override
|
| - Element get staticElement {
|
| - if (_identifier == null) {
|
| - return null;
|
| - }
|
| - return _identifier.staticElement;
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitPrefixedIdentifier(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_prefix, visitor);
|
| - _safelyVisitChild(_identifier, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A prefix unary expression.
|
| - *
|
| - * > prefixExpression ::=
|
| - * > [Token] [Expression]
|
| - */
|
| -class PrefixExpression extends Expression {
|
| - /**
|
| - * The prefix operator being applied to the operand.
|
| - */
|
| - Token operator;
|
| -
|
| - /**
|
| - * The expression computing the operand for the operator.
|
| - */
|
| - Expression _operand;
|
| -
|
| - /**
|
| - * The element associated with the operator based on the static type of the
|
| - * operand, or `null` if the AST structure has not been resolved, if the
|
| - * operator is not user definable, or if the operator could not be resolved.
|
| - */
|
| - MethodElement staticElement;
|
| -
|
| - /**
|
| - * The element associated with the operator based on the propagated type of
|
| - * the operand, or `null` if the AST structure has not been resolved, if the
|
| - * operator is not user definable, or if the operator could not be resolved.
|
| - */
|
| - MethodElement propagatedElement;
|
| -
|
| - /**
|
| - * Initialize a newly created prefix expression.
|
| - */
|
| - PrefixExpression(this.operator, Expression operand) {
|
| - _operand = _becomeParentOf(operand);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => operator;
|
| -
|
| - /**
|
| - * Return the best element available for this operator. If resolution was able
|
| - * to find a better element based on type propagation, that element will be
|
| - * returned. Otherwise, the element found using the result of static analysis
|
| - * will be returned. If resolution has not been performed, then `null` will be
|
| - * returned.
|
| - */
|
| - MethodElement get bestElement {
|
| - MethodElement element = propagatedElement;
|
| - if (element == null) {
|
| - element = staticElement;
|
| - }
|
| - return element;
|
| - }
|
| -
|
| - @override
|
| - Iterable get childEntities =>
|
| - new ChildEntities()..add(operator)..add(_operand);
|
| -
|
| - @override
|
| - Token get endToken => _operand.endToken;
|
| -
|
| - /**
|
| - * Return the expression computing the operand for the operator.
|
| - */
|
| - Expression get operand => _operand;
|
| -
|
| - /**
|
| - * Set the expression computing the operand for the operator to the given
|
| - * [expression].
|
| - */
|
| - void set operand(Expression expression) {
|
| - _operand = _becomeParentOf(expression);
|
| - }
|
| -
|
| - @override
|
| - int get precedence => 14;
|
| -
|
| - /**
|
| - * If the AST structure has been resolved, and the function being invoked is
|
| - * known based on propagated type information, then return the parameter
|
| - * element representing the parameter to which the value of the operand will
|
| - * be bound. Otherwise, return `null`.
|
| - */
|
| - @deprecated // Use "expression.propagatedParameterElement"
|
| - ParameterElement get propagatedParameterElementForOperand {
|
| - return _propagatedParameterElementForOperand;
|
| - }
|
| -
|
| - /**
|
| - * If the AST structure has been resolved, and the function being invoked is
|
| - * known based on static type information, then return the parameter element
|
| - * representing the parameter to which the value of the operand will be bound.
|
| - * Otherwise, return `null`.
|
| - */
|
| - @deprecated // Use "expression.propagatedParameterElement"
|
| - ParameterElement get staticParameterElementForOperand {
|
| - return _staticParameterElementForOperand;
|
| - }
|
| -
|
| - /**
|
| - * If the AST structure has been resolved, and the function being invoked is
|
| - * known based on propagated type information, then return the parameter
|
| - * element representing the parameter to which the value of the operand will
|
| - * be bound. Otherwise, return `null`.
|
| - */
|
| - ParameterElement get _propagatedParameterElementForOperand {
|
| - if (propagatedElement == null) {
|
| - return null;
|
| - }
|
| - List<ParameterElement> parameters = propagatedElement.parameters;
|
| - if (parameters.length < 1) {
|
| - return null;
|
| - }
|
| - return parameters[0];
|
| - }
|
| -
|
| - /**
|
| - * If the AST structure has been resolved, and the function being invoked is
|
| - * known based on static type information, then return the parameter element
|
| - * representing the parameter to which the value of the operand will be bound.
|
| - * Otherwise, return `null`.
|
| - */
|
| - ParameterElement get _staticParameterElementForOperand {
|
| - if (staticElement == null) {
|
| - return null;
|
| - }
|
| - List<ParameterElement> parameters = staticElement.parameters;
|
| - if (parameters.length < 1) {
|
| - return null;
|
| - }
|
| - return parameters[0];
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitPrefixExpression(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_operand, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * The access of a property of an object.
|
| - *
|
| - * Note, however, that accesses to properties of objects can also be represented
|
| - * as [PrefixedIdentifier] nodes in cases where the target is also a simple
|
| - * identifier.
|
| - *
|
| - * > propertyAccess ::=
|
| - * > [Expression] '.' [SimpleIdentifier]
|
| - */
|
| -class PropertyAccess extends Expression {
|
| - /**
|
| - * The expression computing the object defining the property being accessed.
|
| - */
|
| - Expression _target;
|
| -
|
| - /**
|
| - * The property access operator.
|
| - */
|
| - Token operator;
|
| -
|
| - /**
|
| - * The name of the property being accessed.
|
| - */
|
| - SimpleIdentifier _propertyName;
|
| -
|
| - /**
|
| - * Initialize a newly created property access expression.
|
| - */
|
| - PropertyAccess(
|
| - Expression target, this.operator, SimpleIdentifier propertyName) {
|
| - _target = _becomeParentOf(target);
|
| - _propertyName = _becomeParentOf(propertyName);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken {
|
| - if (_target != null) {
|
| - return _target.beginToken;
|
| - }
|
| - return operator;
|
| - }
|
| -
|
| - @override
|
| - Iterable get childEntities =>
|
| - new ChildEntities()..add(_target)..add(operator)..add(_propertyName);
|
| -
|
| - @override
|
| - Token get endToken => _propertyName.endToken;
|
| -
|
| - @override
|
| - bool get isAssignable => true;
|
| -
|
| - /**
|
| - * Return `true` if this expression is cascaded. If it is, then the target of
|
| - * this expression is not stored locally but is stored in the nearest ancestor
|
| - * that is a [CascadeExpression].
|
| - */
|
| - bool get isCascaded =>
|
| - operator != null && operator.type == TokenType.PERIOD_PERIOD;
|
| -
|
| - @override
|
| - int get precedence => 15;
|
| -
|
| - /**
|
| - * Return the name of the property being accessed.
|
| - */
|
| - SimpleIdentifier get propertyName => _propertyName;
|
| -
|
| - /**
|
| - * Set the name of the property being accessed to the given [identifier].
|
| - */
|
| - void set propertyName(SimpleIdentifier identifier) {
|
| - _propertyName = _becomeParentOf(identifier);
|
| - }
|
| -
|
| - /**
|
| - * Return the expression used to compute the receiver of the invocation. If
|
| - * this invocation is not part of a cascade expression, then this is the same
|
| - * as [target]. If this invocation is part of a cascade expression, then the
|
| - * target stored with the cascade expression is returned.
|
| - */
|
| - Expression get realTarget {
|
| - if (isCascaded) {
|
| - AstNode ancestor = parent;
|
| - while (ancestor is! CascadeExpression) {
|
| - if (ancestor == null) {
|
| - return _target;
|
| - }
|
| - ancestor = ancestor.parent;
|
| - }
|
| - return (ancestor as CascadeExpression).target;
|
| - }
|
| - return _target;
|
| - }
|
| -
|
| - /**
|
| - * Return the expression computing the object defining the property being
|
| - * accessed, or `null` if this property access is part of a cascade expression.
|
| - *
|
| - * Use [realTarget] to get the target independent of whether this is part of a
|
| - * cascade expression.
|
| - */
|
| - Expression get target => _target;
|
| -
|
| - /**
|
| - * Set the expression computing the object defining the property being
|
| - * accessed to the given [expression].
|
| - */
|
| - void set target(Expression expression) {
|
| - _target = _becomeParentOf(expression);
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitPropertyAccess(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_target, visitor);
|
| - _safelyVisitChild(_propertyName, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * An AST visitor that will recursively visit all of the nodes in an AST
|
| - * structure. For example, using an instance of this class to visit a [Block]
|
| - * will also cause all of the statements in the block to be visited.
|
| - *
|
| - * Subclasses that override a visit method must either invoke the overridden
|
| - * visit method or must explicitly ask the visited node to visit its children.
|
| - * Failure to do so will cause the children of the visited node to not be
|
| - * visited.
|
| - */
|
| -class RecursiveAstVisitor<R> implements AstVisitor<R> {
|
| - @override
|
| - R visitAdjacentStrings(AdjacentStrings node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitAnnotation(Annotation node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitArgumentList(ArgumentList node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitAsExpression(AsExpression node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitAssertStatement(AssertStatement node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitAssignmentExpression(AssignmentExpression node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitAwaitExpression(AwaitExpression node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitBinaryExpression(BinaryExpression node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitBlock(Block node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitBlockFunctionBody(BlockFunctionBody node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitBooleanLiteral(BooleanLiteral node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitBreakStatement(BreakStatement node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitCascadeExpression(CascadeExpression node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitCatchClause(CatchClause node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitClassDeclaration(ClassDeclaration node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitClassTypeAlias(ClassTypeAlias node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitComment(Comment node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitCommentReference(CommentReference node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitCompilationUnit(CompilationUnit node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitConditionalExpression(ConditionalExpression node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitConstructorDeclaration(ConstructorDeclaration node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitConstructorName(ConstructorName node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitContinueStatement(ContinueStatement node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitDeclaredIdentifier(DeclaredIdentifier node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitDefaultFormalParameter(DefaultFormalParameter node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitDoStatement(DoStatement node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitDoubleLiteral(DoubleLiteral node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitEmptyFunctionBody(EmptyFunctionBody node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitEmptyStatement(EmptyStatement node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitEnumConstantDeclaration(EnumConstantDeclaration node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitEnumDeclaration(EnumDeclaration node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitExportDirective(ExportDirective node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitExpressionFunctionBody(ExpressionFunctionBody node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitExpressionStatement(ExpressionStatement node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitExtendsClause(ExtendsClause node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitFieldDeclaration(FieldDeclaration node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitFieldFormalParameter(FieldFormalParameter node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitForEachStatement(ForEachStatement node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitFormalParameterList(FormalParameterList node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitForStatement(ForStatement node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitFunctionDeclaration(FunctionDeclaration node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitFunctionDeclarationStatement(FunctionDeclarationStatement node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitFunctionExpression(FunctionExpression node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitFunctionTypeAlias(FunctionTypeAlias node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitHideCombinator(HideCombinator node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitIfStatement(IfStatement node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitImplementsClause(ImplementsClause node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitImportDirective(ImportDirective node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitIndexExpression(IndexExpression node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitInstanceCreationExpression(InstanceCreationExpression node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitIntegerLiteral(IntegerLiteral node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitInterpolationExpression(InterpolationExpression node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitInterpolationString(InterpolationString node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitIsExpression(IsExpression node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitLabel(Label node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitLabeledStatement(LabeledStatement node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitLibraryDirective(LibraryDirective node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitLibraryIdentifier(LibraryIdentifier node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitListLiteral(ListLiteral node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitMapLiteral(MapLiteral node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitMapLiteralEntry(MapLiteralEntry node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitMethodDeclaration(MethodDeclaration node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitMethodInvocation(MethodInvocation node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitNamedExpression(NamedExpression node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitNativeClause(NativeClause node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitNativeFunctionBody(NativeFunctionBody node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitNullLiteral(NullLiteral node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitParenthesizedExpression(ParenthesizedExpression node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitPartDirective(PartDirective node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitPartOfDirective(PartOfDirective node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitPostfixExpression(PostfixExpression node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitPrefixedIdentifier(PrefixedIdentifier node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitPrefixExpression(PrefixExpression node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitPropertyAccess(PropertyAccess node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitRedirectingConstructorInvocation(
|
| - RedirectingConstructorInvocation node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitRethrowExpression(RethrowExpression node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitReturnStatement(ReturnStatement node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitScriptTag(ScriptTag node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitShowCombinator(ShowCombinator node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitSimpleFormalParameter(SimpleFormalParameter node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitSimpleIdentifier(SimpleIdentifier node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitSimpleStringLiteral(SimpleStringLiteral node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitStringInterpolation(StringInterpolation node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitSuperConstructorInvocation(SuperConstructorInvocation node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitSuperExpression(SuperExpression node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitSwitchCase(SwitchCase node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitSwitchDefault(SwitchDefault node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitSwitchStatement(SwitchStatement node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitSymbolLiteral(SymbolLiteral node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitThisExpression(ThisExpression node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitThrowExpression(ThrowExpression node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitTryStatement(TryStatement node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitTypeArgumentList(TypeArgumentList node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitTypeName(TypeName node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitTypeParameter(TypeParameter node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitTypeParameterList(TypeParameterList node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitVariableDeclaration(VariableDeclaration node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitVariableDeclarationList(VariableDeclarationList node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitVariableDeclarationStatement(VariableDeclarationStatement node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitWhileStatement(WhileStatement node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitWithClause(WithClause node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitYieldStatement(YieldStatement node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * The invocation of a constructor in the same class from within a constructor's
|
| - * initialization list.
|
| - *
|
| - * > redirectingConstructorInvocation ::=
|
| - * > 'this' ('.' identifier)? arguments
|
| - */
|
| -class RedirectingConstructorInvocation extends ConstructorInitializer {
|
| - /**
|
| - * The token for the 'this' keyword.
|
| - */
|
| - Token thisKeyword;
|
| -
|
| - /**
|
| - * The token for the period before the name of the constructor that is being
|
| - * invoked, or `null` if the unnamed constructor is being invoked.
|
| - */
|
| - Token period;
|
| -
|
| - /**
|
| - * The name of the constructor that is being invoked, or `null` if the unnamed
|
| - * constructor is being invoked.
|
| - */
|
| - SimpleIdentifier _constructorName;
|
| -
|
| - /**
|
| - * The list of arguments to the constructor.
|
| - */
|
| - ArgumentList _argumentList;
|
| -
|
| - /**
|
| - * The element associated with the constructor based on static type
|
| - * information, or `null` if the AST structure has not been resolved or if the
|
| - * constructor could not be resolved.
|
| - */
|
| - ConstructorElement staticElement;
|
| -
|
| - /**
|
| - * Initialize a newly created redirecting invocation to invoke the constructor
|
| - * with the given name with the given arguments. The [constructorName] can be
|
| - * `null` if the constructor being invoked is the unnamed constructor.
|
| - */
|
| - RedirectingConstructorInvocation(this.thisKeyword, this.period,
|
| - SimpleIdentifier constructorName, ArgumentList argumentList) {
|
| - _constructorName = _becomeParentOf(constructorName);
|
| - _argumentList = _becomeParentOf(argumentList);
|
| - }
|
| -
|
| - /**
|
| - * Return the list of arguments to the constructor.
|
| - */
|
| - ArgumentList get argumentList => _argumentList;
|
| -
|
| - /**
|
| - * Set the list of arguments to the constructor to the given [argumentList].
|
| - */
|
| - void set argumentList(ArgumentList argumentList) {
|
| - _argumentList = _becomeParentOf(argumentList);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => thisKeyword;
|
| -
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()
|
| - ..add(thisKeyword)
|
| - ..add(period)
|
| - ..add(_constructorName)
|
| - ..add(_argumentList);
|
| -
|
| - /**
|
| - * Return the name of the constructor that is being invoked, or `null` if the
|
| - * unnamed constructor is being invoked.
|
| - */
|
| - SimpleIdentifier get constructorName => _constructorName;
|
| -
|
| - /**
|
| - * Set the name of the constructor that is being invoked to the given
|
| - * [identifier].
|
| - */
|
| - void set constructorName(SimpleIdentifier identifier) {
|
| - _constructorName = _becomeParentOf(identifier);
|
| - }
|
| -
|
| - @override
|
| - Token get endToken => _argumentList.endToken;
|
| -
|
| - /**
|
| - * Return the token for the 'this' keyword.
|
| - */
|
| - @deprecated // Use "this.thisKeyword"
|
| - Token get keyword => thisKeyword;
|
| -
|
| - /**
|
| - * Set the token for the 'this' keyword to the given [token].
|
| - */
|
| - @deprecated // Use "this.thisKeyword"
|
| - set keyword(Token token) {
|
| - thisKeyword = token;
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) =>
|
| - visitor.visitRedirectingConstructorInvocation(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_constructorName, visitor);
|
| - _safelyVisitChild(_argumentList, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A rethrow expression.
|
| - *
|
| - * > rethrowExpression ::=
|
| - * > 'rethrow'
|
| - */
|
| -class RethrowExpression extends Expression {
|
| - /**
|
| - * The token representing the 'rethrow' keyword.
|
| - */
|
| - Token rethrowKeyword;
|
| -
|
| - /**
|
| - * Initialize a newly created rethrow expression.
|
| - */
|
| - RethrowExpression(this.rethrowKeyword);
|
| -
|
| - @override
|
| - Token get beginToken => rethrowKeyword;
|
| -
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()..add(rethrowKeyword);
|
| -
|
| - @override
|
| - Token get endToken => rethrowKeyword;
|
| -
|
| - /**
|
| - * Return the token representing the 'rethrow' keyword.
|
| - */
|
| - @deprecated // Use "this.rethrowKeyword"
|
| - Token get keyword => rethrowKeyword;
|
| -
|
| - /**
|
| - * Set the token representing the 'rethrow' keyword to the given [token].
|
| - */
|
| - @deprecated // Use "this.rethrowKeyword"
|
| - set keyword(Token token) {
|
| - rethrowKeyword = token;
|
| - }
|
| -
|
| - @override
|
| - int get precedence => 0;
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitRethrowExpression(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - // There are no children to visit.
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A return statement.
|
| - *
|
| - * > returnStatement ::=
|
| - * > 'return' [Expression]? ';'
|
| - */
|
| -class ReturnStatement extends Statement {
|
| - /**
|
| - * The token representing the 'return' keyword.
|
| - */
|
| - Token returnKeyword;
|
| -
|
| - /**
|
| - * The expression computing the value to be returned, or `null` if no explicit
|
| - * value was provided.
|
| - */
|
| - Expression _expression;
|
| -
|
| - /**
|
| - * The semicolon terminating the statement.
|
| - */
|
| - Token semicolon;
|
| -
|
| - /**
|
| - * Initialize a newly created return statement. The [expression] can be `null`
|
| - * if no explicit value was provided.
|
| - */
|
| - ReturnStatement(this.returnKeyword, Expression expression, this.semicolon) {
|
| - _expression = _becomeParentOf(expression);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => returnKeyword;
|
| -
|
| - @override
|
| - Iterable get childEntities =>
|
| - new ChildEntities()..add(returnKeyword)..add(_expression)..add(semicolon);
|
| -
|
| - @override
|
| - Token get endToken => semicolon;
|
| -
|
| - /**
|
| - * Return the expression computing the value to be returned, or `null` if no
|
| - * explicit value was provided.
|
| - */
|
| - Expression get expression => _expression;
|
| -
|
| - /**
|
| - * Set the expression computing the value to be returned to the given
|
| - * [expression].
|
| - */
|
| - void set expression(Expression expression) {
|
| - _expression = _becomeParentOf(expression);
|
| - }
|
| -
|
| - /**
|
| - * Return the token representing the 'return' keyword.
|
| - */
|
| - @deprecated // Use "this.returnKeyword"
|
| - Token get keyword => returnKeyword;
|
| -
|
| - /**
|
| - * Set the token representing the 'return' keyword to the given [token].
|
| - */
|
| - @deprecated // Use "this.returnKeyword"
|
| - set keyword(Token token) {
|
| - returnKeyword = token;
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitReturnStatement(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_expression, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * Traverse the AST from initial child node to successive parents, building a
|
| - * collection of local variable and parameter names visible to the initial child
|
| - * node. In case of name shadowing, the first name seen is the most specific one
|
| - * so names are not redefined.
|
| - *
|
| - * Completion test code coverage is 95%. The two basic blocks that are not
|
| - * executed cannot be executed. They are included for future reference.
|
| - */
|
| -class ScopedNameFinder extends GeneralizingAstVisitor<Object> {
|
| - Declaration _declarationNode;
|
| -
|
| - AstNode _immediateChild;
|
| -
|
| - Map<String, SimpleIdentifier> _locals =
|
| - new HashMap<String, SimpleIdentifier>();
|
| -
|
| - final int _position;
|
| -
|
| - bool _referenceIsWithinLocalFunction = false;
|
| -
|
| - ScopedNameFinder(this._position);
|
| -
|
| - Declaration get declaration => _declarationNode;
|
| -
|
| - Map<String, SimpleIdentifier> get locals => _locals;
|
| -
|
| - @override
|
| - Object visitBlock(Block node) {
|
| - _checkStatements(node.statements);
|
| - return super.visitBlock(node);
|
| - }
|
| -
|
| - @override
|
| - Object visitCatchClause(CatchClause node) {
|
| - _addToScope(node.exceptionParameter);
|
| - _addToScope(node.stackTraceParameter);
|
| - return super.visitCatchClause(node);
|
| - }
|
| -
|
| - @override
|
| - Object visitConstructorDeclaration(ConstructorDeclaration node) {
|
| - if (!identical(_immediateChild, node.parameters)) {
|
| - _addParameters(node.parameters.parameters);
|
| - }
|
| - _declarationNode = node;
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitFieldDeclaration(FieldDeclaration node) {
|
| - _declarationNode = node;
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitForEachStatement(ForEachStatement node) {
|
| - DeclaredIdentifier loopVariable = node.loopVariable;
|
| - if (loopVariable != null) {
|
| - _addToScope(loopVariable.identifier);
|
| - }
|
| - return super.visitForEachStatement(node);
|
| - }
|
| -
|
| - @override
|
| - Object visitForStatement(ForStatement node) {
|
| - if (!identical(_immediateChild, node.variables) && node.variables != null) {
|
| - _addVariables(node.variables.variables);
|
| - }
|
| - return super.visitForStatement(node);
|
| - }
|
| -
|
| - @override
|
| - Object visitFunctionDeclaration(FunctionDeclaration node) {
|
| - if (node.parent is! FunctionDeclarationStatement) {
|
| - _declarationNode = node;
|
| - return null;
|
| - }
|
| - return super.visitFunctionDeclaration(node);
|
| - }
|
| -
|
| - @override
|
| - Object visitFunctionDeclarationStatement(FunctionDeclarationStatement node) {
|
| - _referenceIsWithinLocalFunction = true;
|
| - return super.visitFunctionDeclarationStatement(node);
|
| - }
|
| -
|
| - @override
|
| - Object visitFunctionExpression(FunctionExpression node) {
|
| - if (node.parameters != null &&
|
| - !identical(_immediateChild, node.parameters)) {
|
| - _addParameters(node.parameters.parameters);
|
| - }
|
| - return super.visitFunctionExpression(node);
|
| - }
|
| -
|
| - @override
|
| - Object visitMethodDeclaration(MethodDeclaration node) {
|
| - _declarationNode = node;
|
| - if (node.parameters == null) {
|
| - return null;
|
| - }
|
| - if (!identical(_immediateChild, node.parameters)) {
|
| - _addParameters(node.parameters.parameters);
|
| - }
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitNode(AstNode node) {
|
| - _immediateChild = node;
|
| - AstNode parent = node.parent;
|
| - if (parent != null) {
|
| - parent.accept(this);
|
| - }
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitSwitchMember(SwitchMember node) {
|
| - _checkStatements(node.statements);
|
| - return super.visitSwitchMember(node);
|
| - }
|
| -
|
| - @override
|
| - Object visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
|
| - _declarationNode = node;
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitTypeAlias(TypeAlias node) {
|
| - _declarationNode = node;
|
| - return null;
|
| - }
|
| -
|
| - void _addParameters(NodeList<FormalParameter> vars) {
|
| - for (FormalParameter var2 in vars) {
|
| - _addToScope(var2.identifier);
|
| - }
|
| - }
|
| -
|
| - void _addToScope(SimpleIdentifier identifier) {
|
| - if (identifier != null && _isInRange(identifier)) {
|
| - String name = identifier.name;
|
| - if (!_locals.containsKey(name)) {
|
| - _locals[name] = identifier;
|
| - }
|
| - }
|
| - }
|
| -
|
| - void _addVariables(NodeList<VariableDeclaration> variables) {
|
| - for (VariableDeclaration variable in variables) {
|
| - _addToScope(variable.name);
|
| - }
|
| - }
|
| -
|
| - /**
|
| - * Check the given list of [statements] for any that come before the immediate
|
| - * child and that define a name that would be visible to the immediate child.
|
| - */
|
| - void _checkStatements(List<Statement> statements) {
|
| - for (Statement statement in statements) {
|
| - if (identical(statement, _immediateChild)) {
|
| - return;
|
| - }
|
| - if (statement is VariableDeclarationStatement) {
|
| - _addVariables(statement.variables.variables);
|
| - } else if (statement is FunctionDeclarationStatement &&
|
| - !_referenceIsWithinLocalFunction) {
|
| - _addToScope(statement.functionDeclaration.name);
|
| - }
|
| - }
|
| - }
|
| -
|
| - bool _isInRange(AstNode node) {
|
| - if (_position < 0) {
|
| - // if source position is not set then all nodes are in range
|
| - return true;
|
| - // not reached
|
| - }
|
| - return node.end < _position;
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A script tag that can optionally occur at the beginning of a compilation unit.
|
| - *
|
| - * > scriptTag ::=
|
| - * > '#!' (~NEWLINE)* NEWLINE
|
| - */
|
| -class ScriptTag extends AstNode {
|
| - /**
|
| - * The token representing this script tag.
|
| - */
|
| - Token scriptTag;
|
| -
|
| - /**
|
| - * Initialize a newly created script tag.
|
| - */
|
| - ScriptTag(this.scriptTag);
|
| -
|
| - @override
|
| - Token get beginToken => scriptTag;
|
| -
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()..add(scriptTag);
|
| -
|
| - @override
|
| - Token get endToken => scriptTag;
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitScriptTag(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - // There are no children to visit.
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A combinator that restricts the names being imported to those in a given list.
|
| - *
|
| - * > showCombinator ::=
|
| - * > 'show' [SimpleIdentifier] (',' [SimpleIdentifier])*
|
| - */
|
| -class ShowCombinator extends Combinator {
|
| - /**
|
| - * The list of names from the library that are made visible by this combinator.
|
| - */
|
| - NodeList<SimpleIdentifier> _shownNames;
|
| -
|
| - /**
|
| - * Initialize a newly created import show combinator.
|
| - */
|
| - ShowCombinator(Token keyword, List<SimpleIdentifier> shownNames)
|
| - : super(keyword) {
|
| - _shownNames = new NodeList<SimpleIdentifier>(this, shownNames);
|
| - }
|
| -
|
| - /**
|
| - * TODO(paulberry): add commas.
|
| - */
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()
|
| - ..add(keyword)
|
| - ..addAll(_shownNames);
|
| -
|
| - @override
|
| - Token get endToken => _shownNames.endToken;
|
| -
|
| - /**
|
| - * Return the list of names from the library that are made visible by this
|
| - * combinator.
|
| - */
|
| - NodeList<SimpleIdentifier> get shownNames => _shownNames;
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitShowCombinator(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _shownNames.accept(visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * An AST visitor that will do nothing when visiting an AST node. It is intended
|
| - * to be a superclass for classes that use the visitor pattern primarily as a
|
| - * dispatch mechanism (and hence don't need to recursively visit a whole
|
| - * structure) and that only need to visit a small number of node types.
|
| - */
|
| -class SimpleAstVisitor<R> implements AstVisitor<R> {
|
| - @override
|
| - R visitAdjacentStrings(AdjacentStrings node) => null;
|
| -
|
| - @override
|
| - R visitAnnotation(Annotation node) => null;
|
| -
|
| - @override
|
| - R visitArgumentList(ArgumentList node) => null;
|
| -
|
| - @override
|
| - R visitAsExpression(AsExpression node) => null;
|
| -
|
| - @override
|
| - R visitAssertStatement(AssertStatement node) => null;
|
| -
|
| - @override
|
| - R visitAssignmentExpression(AssignmentExpression node) => null;
|
| -
|
| - @override
|
| - R visitAwaitExpression(AwaitExpression node) => null;
|
| -
|
| - @override
|
| - R visitBinaryExpression(BinaryExpression node) => null;
|
| -
|
| - @override
|
| - R visitBlock(Block node) => null;
|
| -
|
| - @override
|
| - R visitBlockFunctionBody(BlockFunctionBody node) => null;
|
| -
|
| - @override
|
| - R visitBooleanLiteral(BooleanLiteral node) => null;
|
| -
|
| - @override
|
| - R visitBreakStatement(BreakStatement node) => null;
|
| -
|
| - @override
|
| - R visitCascadeExpression(CascadeExpression node) => null;
|
| -
|
| - @override
|
| - R visitCatchClause(CatchClause node) => null;
|
| -
|
| - @override
|
| - R visitClassDeclaration(ClassDeclaration node) => null;
|
| -
|
| - @override
|
| - R visitClassTypeAlias(ClassTypeAlias node) => null;
|
| -
|
| - @override
|
| - R visitComment(Comment node) => null;
|
| -
|
| - @override
|
| - R visitCommentReference(CommentReference node) => null;
|
| -
|
| - @override
|
| - R visitCompilationUnit(CompilationUnit node) => null;
|
| -
|
| - @override
|
| - R visitConditionalExpression(ConditionalExpression node) => null;
|
| -
|
| - @override
|
| - R visitConstructorDeclaration(ConstructorDeclaration node) => null;
|
| -
|
| - @override
|
| - R visitConstructorFieldInitializer(ConstructorFieldInitializer node) => null;
|
| -
|
| - @override
|
| - R visitConstructorName(ConstructorName node) => null;
|
| -
|
| - @override
|
| - R visitContinueStatement(ContinueStatement node) => null;
|
| -
|
| - @override
|
| - R visitDeclaredIdentifier(DeclaredIdentifier node) => null;
|
| -
|
| - @override
|
| - R visitDefaultFormalParameter(DefaultFormalParameter node) => null;
|
| -
|
| - @override
|
| - R visitDoStatement(DoStatement node) => null;
|
| -
|
| - @override
|
| - R visitDoubleLiteral(DoubleLiteral node) => null;
|
| -
|
| - @override
|
| - R visitEmptyFunctionBody(EmptyFunctionBody node) => null;
|
| -
|
| - @override
|
| - R visitEmptyStatement(EmptyStatement node) => null;
|
| -
|
| - @override
|
| - R visitEnumConstantDeclaration(EnumConstantDeclaration node) => null;
|
| -
|
| - @override
|
| - R visitEnumDeclaration(EnumDeclaration node) => null;
|
| -
|
| - @override
|
| - R visitExportDirective(ExportDirective node) => null;
|
| -
|
| - @override
|
| - R visitExpressionFunctionBody(ExpressionFunctionBody node) => null;
|
| -
|
| - @override
|
| - R visitExpressionStatement(ExpressionStatement node) => null;
|
| -
|
| - @override
|
| - R visitExtendsClause(ExtendsClause node) => null;
|
| -
|
| - @override
|
| - R visitFieldDeclaration(FieldDeclaration node) => null;
|
| -
|
| - @override
|
| - R visitFieldFormalParameter(FieldFormalParameter node) => null;
|
| -
|
| - @override
|
| - R visitForEachStatement(ForEachStatement node) => null;
|
| -
|
| - @override
|
| - R visitFormalParameterList(FormalParameterList node) => null;
|
| -
|
| - @override
|
| - R visitForStatement(ForStatement node) => null;
|
| -
|
| - @override
|
| - R visitFunctionDeclaration(FunctionDeclaration node) => null;
|
| -
|
| - @override
|
| - R visitFunctionDeclarationStatement(FunctionDeclarationStatement node) =>
|
| - null;
|
| -
|
| - @override
|
| - R visitFunctionExpression(FunctionExpression node) => null;
|
| -
|
| - @override
|
| - R visitFunctionExpressionInvocation(FunctionExpressionInvocation node) =>
|
| - null;
|
| -
|
| - @override
|
| - R visitFunctionTypeAlias(FunctionTypeAlias node) => null;
|
| -
|
| - @override
|
| - R visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) =>
|
| - null;
|
| -
|
| - @override
|
| - R visitHideCombinator(HideCombinator node) => null;
|
| -
|
| - @override
|
| - R visitIfStatement(IfStatement node) => null;
|
| -
|
| - @override
|
| - R visitImplementsClause(ImplementsClause node) => null;
|
| -
|
| - @override
|
| - R visitImportDirective(ImportDirective node) => null;
|
| -
|
| - @override
|
| - R visitIndexExpression(IndexExpression node) => null;
|
| -
|
| - @override
|
| - R visitInstanceCreationExpression(InstanceCreationExpression node) => null;
|
| -
|
| - @override
|
| - R visitIntegerLiteral(IntegerLiteral node) => null;
|
| -
|
| - @override
|
| - R visitInterpolationExpression(InterpolationExpression node) => null;
|
| -
|
| - @override
|
| - R visitInterpolationString(InterpolationString node) => null;
|
| -
|
| - @override
|
| - R visitIsExpression(IsExpression node) => null;
|
| -
|
| - @override
|
| - R visitLabel(Label node) => null;
|
| -
|
| - @override
|
| - R visitLabeledStatement(LabeledStatement node) => null;
|
| -
|
| - @override
|
| - R visitLibraryDirective(LibraryDirective node) => null;
|
| -
|
| - @override
|
| - R visitLibraryIdentifier(LibraryIdentifier node) => null;
|
| -
|
| - @override
|
| - R visitListLiteral(ListLiteral node) => null;
|
| -
|
| - @override
|
| - R visitMapLiteral(MapLiteral node) => null;
|
| -
|
| - @override
|
| - R visitMapLiteralEntry(MapLiteralEntry node) => null;
|
| -
|
| - @override
|
| - R visitMethodDeclaration(MethodDeclaration node) => null;
|
| -
|
| - @override
|
| - R visitMethodInvocation(MethodInvocation node) => null;
|
| -
|
| - @override
|
| - R visitNamedExpression(NamedExpression node) => null;
|
| -
|
| - @override
|
| - R visitNativeClause(NativeClause node) => null;
|
| -
|
| - @override
|
| - R visitNativeFunctionBody(NativeFunctionBody node) => null;
|
| -
|
| - @override
|
| - R visitNullLiteral(NullLiteral node) => null;
|
| -
|
| - @override
|
| - R visitParenthesizedExpression(ParenthesizedExpression node) => null;
|
| -
|
| - @override
|
| - R visitPartDirective(PartDirective node) => null;
|
| -
|
| - @override
|
| - R visitPartOfDirective(PartOfDirective node) => null;
|
| -
|
| - @override
|
| - R visitPostfixExpression(PostfixExpression node) => null;
|
| -
|
| - @override
|
| - R visitPrefixedIdentifier(PrefixedIdentifier node) => null;
|
| -
|
| - @override
|
| - R visitPrefixExpression(PrefixExpression node) => null;
|
| -
|
| - @override
|
| - R visitPropertyAccess(PropertyAccess node) => null;
|
| -
|
| - @override
|
| - R visitRedirectingConstructorInvocation(
|
| - RedirectingConstructorInvocation node) => null;
|
| -
|
| - @override
|
| - R visitRethrowExpression(RethrowExpression node) => null;
|
| -
|
| - @override
|
| - R visitReturnStatement(ReturnStatement node) => null;
|
| -
|
| - @override
|
| - R visitScriptTag(ScriptTag node) => null;
|
| -
|
| - @override
|
| - R visitShowCombinator(ShowCombinator node) => null;
|
| -
|
| - @override
|
| - R visitSimpleFormalParameter(SimpleFormalParameter node) => null;
|
| -
|
| - @override
|
| - R visitSimpleIdentifier(SimpleIdentifier node) => null;
|
| -
|
| - @override
|
| - R visitSimpleStringLiteral(SimpleStringLiteral node) => null;
|
| -
|
| - @override
|
| - R visitStringInterpolation(StringInterpolation node) => null;
|
| -
|
| - @override
|
| - R visitSuperConstructorInvocation(SuperConstructorInvocation node) => null;
|
| -
|
| - @override
|
| - R visitSuperExpression(SuperExpression node) => null;
|
| -
|
| - @override
|
| - R visitSwitchCase(SwitchCase node) => null;
|
| -
|
| - @override
|
| - R visitSwitchDefault(SwitchDefault node) => null;
|
| -
|
| - @override
|
| - R visitSwitchStatement(SwitchStatement node) => null;
|
| -
|
| - @override
|
| - R visitSymbolLiteral(SymbolLiteral node) => null;
|
| -
|
| - @override
|
| - R visitThisExpression(ThisExpression node) => null;
|
| -
|
| - @override
|
| - R visitThrowExpression(ThrowExpression node) => null;
|
| -
|
| - @override
|
| - R visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) => null;
|
| -
|
| - @override
|
| - R visitTryStatement(TryStatement node) => null;
|
| -
|
| - @override
|
| - R visitTypeArgumentList(TypeArgumentList node) => null;
|
| -
|
| - @override
|
| - R visitTypeName(TypeName node) => null;
|
| -
|
| - @override
|
| - R visitTypeParameter(TypeParameter node) => null;
|
| -
|
| - @override
|
| - R visitTypeParameterList(TypeParameterList node) => null;
|
| -
|
| - @override
|
| - R visitVariableDeclaration(VariableDeclaration node) => null;
|
| -
|
| - @override
|
| - R visitVariableDeclarationList(VariableDeclarationList node) => null;
|
| -
|
| - @override
|
| - R visitVariableDeclarationStatement(VariableDeclarationStatement node) =>
|
| - null;
|
| -
|
| - @override
|
| - R visitWhileStatement(WhileStatement node) => null;
|
| -
|
| - @override
|
| - R visitWithClause(WithClause node) => null;
|
| -
|
| - @override
|
| - R visitYieldStatement(YieldStatement node) => null;
|
| -}
|
| -
|
| -/**
|
| - * A simple formal parameter.
|
| - *
|
| - * > simpleFormalParameter ::=
|
| - * > ('final' [TypeName] | 'var' | [TypeName])? [SimpleIdentifier]
|
| - */
|
| -class SimpleFormalParameter extends NormalFormalParameter {
|
| - /**
|
| - * The token representing either the 'final', 'const' or 'var' keyword, or
|
| - * `null` if no keyword was used.
|
| - */
|
| - Token keyword;
|
| -
|
| - /**
|
| - * The name of the declared type of the parameter, or `null` if the parameter
|
| - * does not have a declared type.
|
| - */
|
| - TypeName _type;
|
| -
|
| - /**
|
| - * Initialize a newly created formal parameter. Either or both of the
|
| - * [comment] and [metadata] can be `null` if the parameter does not have the
|
| - * corresponding attribute. The [keyword] can be `null` if a type was
|
| - * specified. The [type] must be `null` if the keyword is 'var'.
|
| - */
|
| - SimpleFormalParameter(Comment comment, List<Annotation> metadata,
|
| - this.keyword, TypeName type, SimpleIdentifier identifier)
|
| - : super(comment, metadata, identifier) {
|
| - _type = _becomeParentOf(type);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken {
|
| - NodeList<Annotation> metadata = this.metadata;
|
| - if (!metadata.isEmpty) {
|
| - return metadata.beginToken;
|
| - } else if (keyword != null) {
|
| - return keyword;
|
| - } else if (_type != null) {
|
| - return _type.beginToken;
|
| - }
|
| - return identifier.beginToken;
|
| - }
|
| -
|
| - @override
|
| - Iterable get childEntities =>
|
| - super._childEntities..add(keyword)..add(_type)..add(identifier);
|
| -
|
| - @override
|
| - Token get endToken => identifier.endToken;
|
| -
|
| - @override
|
| - bool get isConst => (keyword is KeywordToken) &&
|
| - (keyword as KeywordToken).keyword == Keyword.CONST;
|
| -
|
| - @override
|
| - bool get isFinal => (keyword is KeywordToken) &&
|
| - (keyword as KeywordToken).keyword == Keyword.FINAL;
|
| -
|
| - /**
|
| - * Return the name of the declared type of the parameter, or `null` if the
|
| - * parameter does not have a declared type.
|
| - */
|
| - TypeName get type => _type;
|
| -
|
| - /**
|
| - * Set the name of the declared type of the parameter to the given [typeName].
|
| - */
|
| - void set type(TypeName typeName) {
|
| - _type = _becomeParentOf(typeName);
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitSimpleFormalParameter(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - super.visitChildren(visitor);
|
| - _safelyVisitChild(_type, visitor);
|
| - _safelyVisitChild(identifier, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A simple identifier.
|
| - *
|
| - * > simpleIdentifier ::=
|
| - * > initialCharacter internalCharacter*
|
| - * >
|
| - * > initialCharacter ::= '_' | '$' | letter
|
| - * >
|
| - * > internalCharacter ::= '_' | '$' | letter | digit
|
| - */
|
| -class SimpleIdentifier extends Identifier {
|
| - /**
|
| - * The token representing the identifier.
|
| - */
|
| - Token token;
|
| -
|
| - /**
|
| - * The element associated with this identifier based on static type
|
| - * information, or `null` if the AST structure has not been resolved or if
|
| - * this identifier could not be resolved.
|
| - */
|
| - Element _staticElement;
|
| -
|
| - /**
|
| - * The element associated with this identifier based on propagated type
|
| - * information, or `null` if the AST structure has not been resolved or if
|
| - * this identifier could not be resolved.
|
| - */
|
| - Element _propagatedElement;
|
| -
|
| - /**
|
| - * If this expression is both in a getter and setter context, the
|
| - * [AuxiliaryElements] will be set to hold onto the static and propagated
|
| - * information. The auxiliary element will hold onto the elements from the
|
| - * getter context.
|
| - */
|
| - AuxiliaryElements auxiliaryElements = null;
|
| -
|
| - /**
|
| - * Initialize a newly created identifier.
|
| - */
|
| - SimpleIdentifier(this.token);
|
| -
|
| - @override
|
| - Token get beginToken => token;
|
| -
|
| - @override
|
| - Element get bestElement {
|
| - if (_propagatedElement == null) {
|
| - return _staticElement;
|
| - }
|
| - return _propagatedElement;
|
| - }
|
| -
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()..add(token);
|
| -
|
| - @override
|
| - Token get endToken => token;
|
| -
|
| - /**
|
| - * Returns `true` if this identifier is the "name" part of a prefixed
|
| - * identifier or a method invocation.
|
| - */
|
| - bool get isQualified {
|
| - AstNode parent = this.parent;
|
| - if (parent is PrefixedIdentifier) {
|
| - return identical(parent.identifier, this);
|
| - }
|
| - if (parent is PropertyAccess) {
|
| - return identical(parent.propertyName, this);
|
| - }
|
| - if (parent is MethodInvocation) {
|
| - MethodInvocation invocation = parent;
|
| - return identical(invocation.methodName, this) &&
|
| - invocation.realTarget != null;
|
| - }
|
| - return false;
|
| - }
|
| -
|
| - @override
|
| - bool get isSynthetic => token.isSynthetic;
|
| -
|
| - @override
|
| - String get name => token.lexeme;
|
| -
|
| - @override
|
| - int get precedence => 16;
|
| -
|
| - @override
|
| - Element get propagatedElement => _propagatedElement;
|
| -
|
| - /**
|
| - * Set the element associated with this identifier based on propagated type
|
| - * information to the given [element].
|
| - */
|
| - void set propagatedElement(Element element) {
|
| - _propagatedElement = _validateElement(element);
|
| - }
|
| -
|
| - @override
|
| - Element get staticElement => _staticElement;
|
| -
|
| - /**
|
| - * Set the element associated with this identifier based on static type
|
| - * information to the given [element].
|
| - */
|
| - void set staticElement(Element element) {
|
| - _staticElement = _validateElement(element);
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitSimpleIdentifier(this);
|
| -
|
| - /**
|
| - * Return `true` if this identifier is the name being declared in a
|
| - * declaration.
|
| - */
|
| - bool inDeclarationContext() {
|
| - // TODO(brianwilkerson) Convert this to a getter.
|
| - AstNode parent = this.parent;
|
| - if (parent is CatchClause) {
|
| - CatchClause clause = parent;
|
| - return identical(this, clause.exceptionParameter) ||
|
| - identical(this, clause.stackTraceParameter);
|
| - } else if (parent is ClassDeclaration) {
|
| - return identical(this, parent.name);
|
| - } else if (parent is ClassTypeAlias) {
|
| - return identical(this, parent.name);
|
| - } else if (parent is ConstructorDeclaration) {
|
| - return identical(this, parent.name);
|
| - } else if (parent is DeclaredIdentifier) {
|
| - return identical(this, parent.identifier);
|
| - } else if (parent is EnumDeclaration) {
|
| - return identical(this, parent.name);
|
| - } else if (parent is EnumConstantDeclaration) {
|
| - return identical(this, parent.name);
|
| - } else if (parent is FunctionDeclaration) {
|
| - return identical(this, parent.name);
|
| - } else if (parent is FunctionTypeAlias) {
|
| - return identical(this, parent.name);
|
| - } else if (parent is ImportDirective) {
|
| - return identical(this, parent.prefix);
|
| - } else if (parent is Label) {
|
| - return identical(this, parent.label) &&
|
| - (parent.parent is LabeledStatement);
|
| - } else if (parent is MethodDeclaration) {
|
| - return identical(this, parent.name);
|
| - } else if (parent is FunctionTypedFormalParameter ||
|
| - parent is SimpleFormalParameter) {
|
| - return identical(this, (parent as NormalFormalParameter).identifier);
|
| - } else if (parent is TypeParameter) {
|
| - return identical(this, parent.name);
|
| - } else if (parent is VariableDeclaration) {
|
| - return identical(this, parent.name);
|
| - }
|
| - return false;
|
| - }
|
| -
|
| - /**
|
| - * Return `true` if this expression is computing a right-hand value.
|
| - *
|
| - * Note that [inGetterContext] and [inSetterContext] are not opposites, nor
|
| - * are they mutually exclusive. In other words, it is possible for both
|
| - * methods to return `true` when invoked on the same node.
|
| - */
|
| - bool inGetterContext() {
|
| - // TODO(brianwilkerson) Convert this to a getter.
|
| - AstNode parent = this.parent;
|
| - AstNode target = this;
|
| - // skip prefix
|
| - if (parent is PrefixedIdentifier) {
|
| - PrefixedIdentifier prefixed = parent as PrefixedIdentifier;
|
| - if (identical(prefixed.prefix, this)) {
|
| - return true;
|
| - }
|
| - parent = prefixed.parent;
|
| - target = prefixed;
|
| - } else if (parent is PropertyAccess) {
|
| - PropertyAccess access = parent as PropertyAccess;
|
| - if (identical(access.target, this)) {
|
| - return true;
|
| - }
|
| - parent = access.parent;
|
| - target = access;
|
| - }
|
| - // skip label
|
| - if (parent is Label) {
|
| - return false;
|
| - }
|
| - // analyze usage
|
| - if (parent is AssignmentExpression) {
|
| - if (identical(parent.leftHandSide, target) &&
|
| - parent.operator.type == TokenType.EQ) {
|
| - return false;
|
| - }
|
| - }
|
| - if (parent is ForEachStatement) {
|
| - if (identical(parent.identifier, target)) {
|
| - return false;
|
| - }
|
| - }
|
| - return true;
|
| - }
|
| -
|
| - /**
|
| - * Return `true` if this expression is computing a left-hand value.
|
| - *
|
| - * Note that [inGetterContext] and [inSetterContext] are not opposites, nor
|
| - * are they mutually exclusive. In other words, it is possible for both
|
| - * methods to return `true` when invoked on the same node.
|
| - */
|
| - bool inSetterContext() {
|
| - // TODO(brianwilkerson) Convert this to a getter.
|
| - AstNode parent = this.parent;
|
| - AstNode target = this;
|
| - // skip prefix
|
| - if (parent is PrefixedIdentifier) {
|
| - PrefixedIdentifier prefixed = parent as PrefixedIdentifier;
|
| - // if this is the prefix, then return false
|
| - if (identical(prefixed.prefix, this)) {
|
| - return false;
|
| - }
|
| - parent = prefixed.parent;
|
| - target = prefixed;
|
| - } else if (parent is PropertyAccess) {
|
| - PropertyAccess access = parent as PropertyAccess;
|
| - if (identical(access.target, this)) {
|
| - return false;
|
| - }
|
| - parent = access.parent;
|
| - target = access;
|
| - }
|
| - // analyze usage
|
| - if (parent is PrefixExpression) {
|
| - return parent.operator.type.isIncrementOperator;
|
| - } else if (parent is PostfixExpression) {
|
| - return true;
|
| - } else if (parent is AssignmentExpression) {
|
| - return identical(parent.leftHandSide, target);
|
| - } else if (parent is ForEachStatement) {
|
| - return identical(parent.identifier, target);
|
| - }
|
| - return false;
|
| - }
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - // There are no children to visit.
|
| - }
|
| -
|
| - /**
|
| - * Return the given element if it is valid, or report the problem and return
|
| - * `null` if it is not appropriate.
|
| - *
|
| - * The [parent] is the parent of the element, used for reporting when there is
|
| - * a problem.
|
| - * The [isValid] is `true` if the element is appropriate.
|
| - * The [element] is the element to be associated with this identifier.
|
| - */
|
| - Element _returnOrReportElement(
|
| - AstNode parent, bool isValid, Element element) {
|
| - if (!isValid) {
|
| - AnalysisEngine.instance.logger.logInformation(
|
| - "Internal error: attempting to set the name of a ${parent.runtimeType} to a ${element.runtimeType}",
|
| - new CaughtException(new AnalysisException(), null));
|
| - return null;
|
| - }
|
| - return element;
|
| - }
|
| -
|
| - /**
|
| - * Return the given [element] if it is an appropriate element based on the
|
| - * parent of this identifier, or `null` if it is not appropriate.
|
| - */
|
| - Element _validateElement(Element element) {
|
| - if (element == null) {
|
| - return null;
|
| - }
|
| - AstNode parent = this.parent;
|
| - if (parent is ClassDeclaration && identical(parent.name, this)) {
|
| - return _returnOrReportElement(parent, element is ClassElement, element);
|
| - } else if (parent is ClassTypeAlias && identical(parent.name, this)) {
|
| - return _returnOrReportElement(parent, element is ClassElement, element);
|
| - } else if (parent is DeclaredIdentifier &&
|
| - identical(parent.identifier, this)) {
|
| - return _returnOrReportElement(
|
| - parent, element is LocalVariableElement, element);
|
| - } else if (parent is FormalParameter &&
|
| - identical(parent.identifier, this)) {
|
| - return _returnOrReportElement(
|
| - parent, element is ParameterElement, element);
|
| - } else if (parent is FunctionDeclaration && identical(parent.name, this)) {
|
| - return _returnOrReportElement(
|
| - parent, element is ExecutableElement, element);
|
| - } else if (parent is FunctionTypeAlias && identical(parent.name, this)) {
|
| - return _returnOrReportElement(
|
| - parent, element is FunctionTypeAliasElement, element);
|
| - } else if (parent is MethodDeclaration && identical(parent.name, this)) {
|
| - return _returnOrReportElement(
|
| - parent, element is ExecutableElement, element);
|
| - } else if (parent is TypeParameter && identical(parent.name, this)) {
|
| - return _returnOrReportElement(
|
| - parent, element is TypeParameterElement, element);
|
| - } else if (parent is VariableDeclaration && identical(parent.name, this)) {
|
| - return _returnOrReportElement(
|
| - parent, element is VariableElement, element);
|
| - }
|
| - return element;
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A string literal expression that does not contain any interpolations.
|
| - *
|
| - * > simpleStringLiteral ::=
|
| - * > rawStringLiteral
|
| - * > | basicStringLiteral
|
| - * >
|
| - * > rawStringLiteral ::=
|
| - * > 'r' basicStringLiteral
|
| - * >
|
| - * > simpleStringLiteral ::=
|
| - * > multiLineStringLiteral
|
| - * > | singleLineStringLiteral
|
| - * >
|
| - * > multiLineStringLiteral ::=
|
| - * > "'''" characters "'''"
|
| - * > | '"""' characters '"""'
|
| - * >
|
| - * > singleLineStringLiteral ::=
|
| - * > "'" characters "'"
|
| - * > | '"' characters '"'
|
| - */
|
| -class SimpleStringLiteral extends SingleStringLiteral {
|
| - /**
|
| - * The token representing the literal.
|
| - */
|
| - Token literal;
|
| -
|
| - /**
|
| - * The value of the literal.
|
| - */
|
| - String _value;
|
| -
|
| - /**
|
| - * The toolkit specific element associated with this literal, or `null`.
|
| - */
|
| - @deprecated // No replacement
|
| - Element toolkitElement;
|
| -
|
| - /**
|
| - * Initialize a newly created simple string literal.
|
| - */
|
| - SimpleStringLiteral(this.literal, String value) {
|
| - _value = StringUtilities.intern(value);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => literal;
|
| -
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()..add(literal);
|
| -
|
| - @override
|
| - int get contentsEnd => offset + _helper.end;
|
| -
|
| - @override
|
| - int get contentsOffset => offset + _helper.start;
|
| -
|
| - @override
|
| - Token get endToken => literal;
|
| -
|
| - @override
|
| - bool get isMultiline => _helper.isMultiline;
|
| -
|
| - @override
|
| - bool get isRaw => _helper.isRaw;
|
| -
|
| - @override
|
| - bool get isSingleQuoted => _helper.isSingleQuoted;
|
| -
|
| - @override
|
| - bool get isSynthetic => literal.isSynthetic;
|
| -
|
| - /**
|
| - * Return the value of the literal.
|
| - */
|
| - String get value => _value;
|
| -
|
| - /**
|
| - * Set the value of the literal to the given [string].
|
| - */
|
| - void set value(String string) {
|
| - _value = StringUtilities.intern(_value);
|
| - }
|
| -
|
| - StringLexemeHelper get _helper {
|
| - return new StringLexemeHelper(literal.lexeme, true, true);
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitSimpleStringLiteral(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - // There are no children to visit.
|
| - }
|
| -
|
| - @override
|
| - void _appendStringValue(StringBuffer buffer) {
|
| - buffer.write(value);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A single string literal expression.
|
| - *
|
| - * > singleStringLiteral ::=
|
| - * > [SimpleStringLiteral]
|
| - * > | [StringInterpolation]
|
| - */
|
| -abstract class SingleStringLiteral extends StringLiteral {
|
| - /**
|
| - * Return the offset of the after-last contents character.
|
| - */
|
| - int get contentsEnd;
|
| -
|
| - /**
|
| - * Return the offset of the first contents character.
|
| - * If the string is multiline, then leading whitespaces are skipped.
|
| - */
|
| - int get contentsOffset;
|
| -
|
| - /**
|
| - * Return `true` if this string literal is a multi-line string.
|
| - */
|
| - bool get isMultiline;
|
| -
|
| - /**
|
| - * Return `true` if this string literal is a raw string.
|
| - */
|
| - bool get isRaw;
|
| -
|
| - /**
|
| - * Return `true` if this string literal uses single qoutes (' or ''').
|
| - * Return `false` if this string literal uses double qoutes (" or """).
|
| - */
|
| - bool get isSingleQuoted;
|
| -}
|
| -
|
| -/**
|
| - * A node that represents a statement.
|
| - *
|
| - * > statement ::=
|
| - * > [Block]
|
| - * > | [VariableDeclarationStatement]
|
| - * > | [ForStatement]
|
| - * > | [ForEachStatement]
|
| - * > | [WhileStatement]
|
| - * > | [DoStatement]
|
| - * > | [SwitchStatement]
|
| - * > | [IfStatement]
|
| - * > | [TryStatement]
|
| - * > | [BreakStatement]
|
| - * > | [ContinueStatement]
|
| - * > | [ReturnStatement]
|
| - * > | [ExpressionStatement]
|
| - * > | [FunctionDeclarationStatement]
|
| - */
|
| -abstract class Statement extends AstNode {
|
| - /**
|
| - * If this is a labeled statement, return the unlabeled portion of the
|
| - * statement. Otherwise return the statement itself.
|
| - */
|
| - Statement get unlabeled => this;
|
| -}
|
| -
|
| -/**
|
| - * A string interpolation literal.
|
| - *
|
| - * > stringInterpolation ::=
|
| - * > ''' [InterpolationElement]* '''
|
| - * > | '"' [InterpolationElement]* '"'
|
| - */
|
| -class StringInterpolation extends SingleStringLiteral {
|
| - /**
|
| - * The elements that will be composed to produce the resulting string.
|
| - */
|
| - NodeList<InterpolationElement> _elements;
|
| -
|
| - /**
|
| - * Initialize a newly created string interpolation expression.
|
| - */
|
| - StringInterpolation(List<InterpolationElement> elements) {
|
| - _elements = new NodeList<InterpolationElement>(this, elements);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => _elements.beginToken;
|
| -
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()..addAll(_elements);
|
| -
|
| - @override
|
| - int get contentsEnd {
|
| - InterpolationString element = _elements.last;
|
| - return element.contentsEnd;
|
| - }
|
| -
|
| - @override
|
| - int get contentsOffset {
|
| - InterpolationString element = _elements.first;
|
| - return element.contentsOffset;
|
| - }
|
| -
|
| - /**
|
| - * Return the elements that will be composed to produce the resulting string.
|
| - */
|
| - NodeList<InterpolationElement> get elements => _elements;
|
| -
|
| - @override
|
| - Token get endToken => _elements.endToken;
|
| -
|
| - @override
|
| - bool get isMultiline => _firstHelper.isMultiline;
|
| -
|
| - @override
|
| - bool get isRaw => false;
|
| -
|
| - @override
|
| - bool get isSingleQuoted => _firstHelper.isSingleQuoted;
|
| -
|
| - StringLexemeHelper get _firstHelper {
|
| - InterpolationString lastString = _elements.first;
|
| - String lexeme = lastString.contents.lexeme;
|
| - return new StringLexemeHelper(lexeme, true, false);
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitStringInterpolation(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _elements.accept(visitor);
|
| - }
|
| -
|
| - @override
|
| - void _appendStringValue(StringBuffer buffer) {
|
| - throw new IllegalArgumentException();
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A helper for analyzing string lexemes.
|
| - */
|
| -class StringLexemeHelper {
|
| - final String lexeme;
|
| - final bool isFirst;
|
| - final bool isLast;
|
| -
|
| - bool isRaw = false;
|
| - bool isSingleQuoted = false;
|
| - bool isMultiline = false;
|
| - int start = 0;
|
| - int end;
|
| -
|
| - StringLexemeHelper(this.lexeme, this.isFirst, this.isLast) {
|
| - if (isFirst) {
|
| - isRaw = StringUtilities.startsWithChar(lexeme, 0x72);
|
| - if (isRaw) {
|
| - start++;
|
| - }
|
| - if (StringUtilities.startsWith3(lexeme, start, 0x27, 0x27, 0x27)) {
|
| - isSingleQuoted = true;
|
| - isMultiline = true;
|
| - start += 3;
|
| - start = _trimInitialWhitespace(start);
|
| - } else if (StringUtilities.startsWith3(lexeme, start, 0x22, 0x22, 0x22)) {
|
| - isSingleQuoted = false;
|
| - isMultiline = true;
|
| - start += 3;
|
| - start = _trimInitialWhitespace(start);
|
| - } else if (start < lexeme.length && lexeme.codeUnitAt(start) == 0x27) {
|
| - isSingleQuoted = true;
|
| - isMultiline = false;
|
| - start++;
|
| - } else if (start < lexeme.length && lexeme.codeUnitAt(start) == 0x22) {
|
| - isSingleQuoted = false;
|
| - isMultiline = false;
|
| - start++;
|
| - }
|
| - }
|
| - end = lexeme.length;
|
| - if (isLast) {
|
| - if (start + 3 <= end &&
|
| - (StringUtilities.endsWith3(lexeme, 0x22, 0x22, 0x22) ||
|
| - StringUtilities.endsWith3(lexeme, 0x27, 0x27, 0x27))) {
|
| - end -= 3;
|
| - } else if (start + 1 <= end &&
|
| - (StringUtilities.endsWithChar(lexeme, 0x22) ||
|
| - StringUtilities.endsWithChar(lexeme, 0x27))) {
|
| - end -= 1;
|
| - }
|
| - }
|
| - }
|
| -
|
| - /**
|
| - * Given the [lexeme] for a multi-line string whose content begins at the
|
| - * given [start] index, return the index of the first character that is
|
| - * included in the value of the string. According to the specification:
|
| - *
|
| - * If the first line of a multiline string consists solely of the whitespace
|
| - * characters defined by the production WHITESPACE 20.1), possibly prefixed
|
| - * by \, then that line is ignored, including the new line at its end.
|
| - */
|
| - int _trimInitialWhitespace(int start) {
|
| - int length = lexeme.length;
|
| - int index = start;
|
| - while (index < length) {
|
| - int currentChar = lexeme.codeUnitAt(index);
|
| - if (currentChar == 0x0D) {
|
| - if (index + 1 < length && lexeme.codeUnitAt(index + 1) == 0x0A) {
|
| - return index + 2;
|
| - }
|
| - return index + 1;
|
| - } else if (currentChar == 0x0A) {
|
| - return index + 1;
|
| - } else if (currentChar == 0x5C) {
|
| - if (index + 1 >= length) {
|
| - return start;
|
| - }
|
| - currentChar = lexeme.codeUnitAt(index + 1);
|
| - if (currentChar != 0x0D &&
|
| - currentChar != 0x0A &&
|
| - currentChar != 0x09 &&
|
| - currentChar != 0x20) {
|
| - return start;
|
| - }
|
| - } else if (currentChar != 0x09 && currentChar != 0x20) {
|
| - return start;
|
| - }
|
| - index++;
|
| - }
|
| - return start;
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A string literal expression.
|
| - *
|
| - * > stringLiteral ::=
|
| - * > [SimpleStringLiteral]
|
| - * > | [AdjacentStrings]
|
| - * > | [StringInterpolation]
|
| - */
|
| -abstract class StringLiteral extends Literal {
|
| - /**
|
| - * Return the value of the string literal, or `null` if the string is not a
|
| - * constant string without any string interpolation.
|
| - */
|
| - String get stringValue {
|
| - StringBuffer buffer = new StringBuffer();
|
| - try {
|
| - _appendStringValue(buffer);
|
| - } on IllegalArgumentException {
|
| - return null;
|
| - }
|
| - return buffer.toString();
|
| - }
|
| -
|
| - /**
|
| - * Append the value of this string literal to the given [buffer]. Throw an
|
| - * [IllegalArgumentException] if the string is not a constant string without
|
| - * any string interpolation.
|
| - */
|
| - @deprecated // Use "this.stringValue"
|
| - void appendStringValue(StringBuffer buffer) => _appendStringValue(buffer);
|
| -
|
| - /**
|
| - * Append the value of this string literal to the given [buffer]. Throw an
|
| - * [IllegalArgumentException] if the string is not a constant string without
|
| - * any string interpolation.
|
| - */
|
| - void _appendStringValue(StringBuffer buffer);
|
| -}
|
| -
|
| -/**
|
| - * The invocation of a superclass' constructor from within a constructor's
|
| - * initialization list.
|
| - *
|
| - * > superInvocation ::=
|
| - * > 'super' ('.' [SimpleIdentifier])? [ArgumentList]
|
| - */
|
| -class SuperConstructorInvocation extends ConstructorInitializer {
|
| - /**
|
| - * The token for the 'super' keyword.
|
| - */
|
| - Token superKeyword;
|
| -
|
| - /**
|
| - * The token for the period before the name of the constructor that is being
|
| - * invoked, or `null` if the unnamed constructor is being invoked.
|
| - */
|
| - Token period;
|
| -
|
| - /**
|
| - * The name of the constructor that is being invoked, or `null` if the unnamed
|
| - * constructor is being invoked.
|
| - */
|
| - SimpleIdentifier _constructorName;
|
| -
|
| - /**
|
| - * The list of arguments to the constructor.
|
| - */
|
| - ArgumentList _argumentList;
|
| -
|
| - /**
|
| - * The element associated with the constructor based on static type
|
| - * information, or `null` if the AST structure has not been resolved or if the
|
| - * constructor could not be resolved.
|
| - */
|
| - ConstructorElement staticElement;
|
| -
|
| - /**
|
| - * Initialize a newly created super invocation to invoke the inherited
|
| - * constructor with the given name with the given arguments. The [period] and
|
| - * [constructorName] can be `null` if the constructor being invoked is the
|
| - * unnamed constructor.
|
| - */
|
| - SuperConstructorInvocation(this.superKeyword, this.period,
|
| - SimpleIdentifier constructorName, ArgumentList argumentList) {
|
| - _constructorName = _becomeParentOf(constructorName);
|
| - _argumentList = _becomeParentOf(argumentList);
|
| - }
|
| -
|
| - /**
|
| - * Return the list of arguments to the constructor.
|
| - */
|
| - ArgumentList get argumentList => _argumentList;
|
| -
|
| - /**
|
| - * Set the list of arguments to the constructor to the given [argumentList].
|
| - */
|
| - void set argumentList(ArgumentList argumentList) {
|
| - _argumentList = _becomeParentOf(argumentList);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => superKeyword;
|
| -
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()
|
| - ..add(superKeyword)
|
| - ..add(period)
|
| - ..add(_constructorName)
|
| - ..add(_argumentList);
|
| -
|
| - /**
|
| - * Return the name of the constructor that is being invoked, or `null` if the
|
| - * unnamed constructor is being invoked.
|
| - */
|
| - SimpleIdentifier get constructorName => _constructorName;
|
| -
|
| - /**
|
| - * Set the name of the constructor that is being invoked to the given
|
| - * [identifier].
|
| - */
|
| - void set constructorName(SimpleIdentifier identifier) {
|
| - _constructorName = _becomeParentOf(identifier);
|
| - }
|
| -
|
| - @override
|
| - Token get endToken => _argumentList.endToken;
|
| -
|
| - /**
|
| - * Return the token for the 'super' keyword.
|
| - */
|
| - @deprecated // Use "this.superKeyword"
|
| - Token get keyword => superKeyword;
|
| -
|
| - /**
|
| - * Set the token for the 'super' keyword to the given [token].
|
| - */
|
| - @deprecated // Use "this.superKeyword"
|
| - set keyword(Token token) {
|
| - superKeyword = token;
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitSuperConstructorInvocation(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_constructorName, visitor);
|
| - _safelyVisitChild(_argumentList, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A super expression.
|
| - *
|
| - * > superExpression ::=
|
| - * > 'super'
|
| - */
|
| -class SuperExpression extends Expression {
|
| - /**
|
| - * The token representing the 'super' keyword.
|
| - */
|
| - Token superKeyword;
|
| -
|
| - /**
|
| - * Initialize a newly created super expression.
|
| - */
|
| - SuperExpression(this.superKeyword);
|
| -
|
| - @override
|
| - Token get beginToken => superKeyword;
|
| -
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()..add(superKeyword);
|
| -
|
| - @override
|
| - Token get endToken => superKeyword;
|
| -
|
| - /**
|
| - * Return the token for the 'super' keyword.
|
| - */
|
| - @deprecated // Use "this.superKeyword"
|
| - Token get keyword => superKeyword;
|
| -
|
| - /**
|
| - * Set the token for the 'super' keyword to the given [token].
|
| - */
|
| - @deprecated // Use "this.superKeyword"
|
| - set keyword(Token token) {
|
| - superKeyword = token;
|
| - }
|
| -
|
| - @override
|
| - int get precedence => 16;
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitSuperExpression(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - // There are no children to visit.
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A case in a switch statement.
|
| - *
|
| - * > switchCase ::=
|
| - * > [SimpleIdentifier]* 'case' [Expression] ':' [Statement]*
|
| - */
|
| -class SwitchCase extends SwitchMember {
|
| - /**
|
| - * The expression controlling whether the statements will be executed.
|
| - */
|
| - Expression _expression;
|
| -
|
| - /**
|
| - * Initialize a newly created switch case. The list of [labels] can be `null`
|
| - * if there are no labels.
|
| - */
|
| - SwitchCase(List<Label> labels, Token keyword, Expression expression,
|
| - Token colon, List<Statement> statements)
|
| - : super(labels, keyword, colon, statements) {
|
| - _expression = _becomeParentOf(expression);
|
| - }
|
| -
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()
|
| - ..addAll(labels)
|
| - ..add(keyword)
|
| - ..add(_expression)
|
| - ..add(colon)
|
| - ..addAll(statements);
|
| -
|
| - /**
|
| - * Return the expression controlling whether the statements will be executed.
|
| - */
|
| - Expression get expression => _expression;
|
| -
|
| - /**
|
| - * Set the expression controlling whether the statements will be executed to
|
| - * the given [expression].
|
| - */
|
| - void set expression(Expression expression) {
|
| - _expression = _becomeParentOf(expression);
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitSwitchCase(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - labels.accept(visitor);
|
| - _safelyVisitChild(_expression, visitor);
|
| - statements.accept(visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * The default case in a switch statement.
|
| - *
|
| - * > switchDefault ::=
|
| - * > [SimpleIdentifier]* 'default' ':' [Statement]*
|
| - */
|
| -class SwitchDefault extends SwitchMember {
|
| - /**
|
| - * Initialize a newly created switch default. The list of [labels] can be
|
| - * `null` if there are no labels.
|
| - */
|
| - SwitchDefault(List<Label> labels, Token keyword, Token colon,
|
| - List<Statement> statements)
|
| - : super(labels, keyword, colon, statements);
|
| -
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()
|
| - ..addAll(labels)
|
| - ..add(keyword)
|
| - ..add(colon)
|
| - ..addAll(statements);
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitSwitchDefault(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - labels.accept(visitor);
|
| - statements.accept(visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * An element within a switch statement.
|
| - *
|
| - * > switchMember ::=
|
| - * > switchCase
|
| - * > | switchDefault
|
| - */
|
| -abstract class SwitchMember extends AstNode {
|
| - /**
|
| - * The labels associated with the switch member.
|
| - */
|
| - NodeList<Label> _labels;
|
| -
|
| - /**
|
| - * The token representing the 'case' or 'default' keyword.
|
| - */
|
| - Token keyword;
|
| -
|
| - /**
|
| - * The colon separating the keyword or the expression from the statements.
|
| - */
|
| - Token colon;
|
| -
|
| - /**
|
| - * The statements that will be executed if this switch member is selected.
|
| - */
|
| - NodeList<Statement> _statements;
|
| -
|
| - /**
|
| - * Initialize a newly created switch member. The list of [labels] can be
|
| - * `null` if there are no labels.
|
| - */
|
| - SwitchMember(List<Label> labels, this.keyword, this.colon,
|
| - List<Statement> statements) {
|
| - _labels = new NodeList<Label>(this, labels);
|
| - _statements = new NodeList<Statement>(this, statements);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken {
|
| - if (!_labels.isEmpty) {
|
| - return _labels.beginToken;
|
| - }
|
| - return keyword;
|
| - }
|
| -
|
| - @override
|
| - Token get endToken {
|
| - if (!_statements.isEmpty) {
|
| - return _statements.endToken;
|
| - }
|
| - return colon;
|
| - }
|
| -
|
| - /**
|
| - * Return the labels associated with the switch member.
|
| - */
|
| - NodeList<Label> get labels => _labels;
|
| -
|
| - /**
|
| - * Return the statements that will be executed if this switch member is
|
| - * selected.
|
| - */
|
| - NodeList<Statement> get statements => _statements;
|
| -}
|
| -
|
| -/**
|
| - * A switch statement.
|
| - *
|
| - * > switchStatement ::=
|
| - * > 'switch' '(' [Expression] ')' '{' [SwitchCase]* [SwitchDefault]? '}'
|
| - */
|
| -class SwitchStatement extends Statement {
|
| - /**
|
| - * The token representing the 'switch' keyword.
|
| - */
|
| - Token switchKeyword;
|
| -
|
| - /**
|
| - * The left parenthesis.
|
| - */
|
| - Token leftParenthesis;
|
| -
|
| - /**
|
| - * The expression used to determine which of the switch members will be
|
| - * selected.
|
| - */
|
| - Expression _expression;
|
| -
|
| - /**
|
| - * The right parenthesis.
|
| - */
|
| - Token rightParenthesis;
|
| -
|
| - /**
|
| - * The left curly bracket.
|
| - */
|
| - Token leftBracket;
|
| -
|
| - /**
|
| - * The switch members that can be selected by the expression.
|
| - */
|
| - NodeList<SwitchMember> _members;
|
| -
|
| - /**
|
| - * The right curly bracket.
|
| - */
|
| - Token rightBracket;
|
| -
|
| - /**
|
| - * Initialize a newly created switch statement. The list of [members] can be
|
| - * `null` if there are no switch members.
|
| - */
|
| - SwitchStatement(this.switchKeyword, this.leftParenthesis,
|
| - Expression expression, this.rightParenthesis, this.leftBracket,
|
| - List<SwitchMember> members, this.rightBracket) {
|
| - _expression = _becomeParentOf(expression);
|
| - _members = new NodeList<SwitchMember>(this, members);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => switchKeyword;
|
| -
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()
|
| - ..add(switchKeyword)
|
| - ..add(leftParenthesis)
|
| - ..add(_expression)
|
| - ..add(rightParenthesis)
|
| - ..add(leftBracket)
|
| - ..addAll(_members)
|
| - ..add(rightBracket);
|
| -
|
| - @override
|
| - Token get endToken => rightBracket;
|
| -
|
| - /**
|
| - * Return the expression used to determine which of the switch members will be
|
| - * selected.
|
| - */
|
| - Expression get expression => _expression;
|
| -
|
| - /**
|
| - * Set the expression used to determine which of the switch members will be
|
| - * selected to the given [expression].
|
| - */
|
| - void set expression(Expression expression) {
|
| - _expression = _becomeParentOf(expression);
|
| - }
|
| -
|
| - /**
|
| - * Return the token representing the 'switch' keyword.
|
| - */
|
| - @deprecated // Use "this.switchKeyword"
|
| - Token get keyword => switchKeyword;
|
| -
|
| - /**
|
| - * Set the token representing the 'switch' keyword to the given [token].
|
| - */
|
| - @deprecated // Use "this.switchKeyword"
|
| - set keyword(Token token) {
|
| - switchKeyword = token;
|
| - }
|
| -
|
| - /**
|
| - * Return the switch members that can be selected by the expression.
|
| - */
|
| - NodeList<SwitchMember> get members => _members;
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitSwitchStatement(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_expression, visitor);
|
| - _members.accept(visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A symbol literal expression.
|
| - *
|
| - * > symbolLiteral ::=
|
| - * > '#' (operator | (identifier ('.' identifier)*))
|
| - */
|
| -class SymbolLiteral extends Literal {
|
| - /**
|
| - * The token introducing the literal.
|
| - */
|
| - Token poundSign;
|
| -
|
| - /**
|
| - * The components of the literal.
|
| - */
|
| - final List<Token> components;
|
| -
|
| - /**
|
| - * Initialize a newly created symbol literal.
|
| - */
|
| - SymbolLiteral(this.poundSign, this.components);
|
| -
|
| - @override
|
| - Token get beginToken => poundSign;
|
| -
|
| - /**
|
| - * TODO(paulberry): add "." tokens.
|
| - */
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()
|
| - ..add(poundSign)
|
| - ..addAll(components);
|
| -
|
| - @override
|
| - Token get endToken => components[components.length - 1];
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitSymbolLiteral(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - // There are no children to visit.
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A this expression.
|
| - *
|
| - * > thisExpression ::=
|
| - * > 'this'
|
| - */
|
| -class ThisExpression extends Expression {
|
| - /**
|
| - * The token representing the 'this' keyword.
|
| - */
|
| - Token thisKeyword;
|
| -
|
| - /**
|
| - * Initialize a newly created this expression.
|
| - */
|
| - ThisExpression(this.thisKeyword);
|
| -
|
| - @override
|
| - Token get beginToken => thisKeyword;
|
| -
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()..add(thisKeyword);
|
| -
|
| - @override
|
| - Token get endToken => thisKeyword;
|
| -
|
| - /**
|
| - * Return the token representing the 'this' keyword.
|
| - */
|
| - @deprecated // Use "this.thisKeyword"
|
| - Token get keyword => thisKeyword;
|
| -
|
| - /**
|
| - * Set the token representing the 'this' keyword to the given [token].
|
| - */
|
| - @deprecated // Use "this.thisKeyword"
|
| - set keyword(Token token) {
|
| - thisKeyword = token;
|
| - }
|
| -
|
| - @override
|
| - int get precedence => 16;
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitThisExpression(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - // There are no children to visit.
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A throw expression.
|
| - *
|
| - * > throwExpression ::=
|
| - * > 'throw' [Expression]
|
| - */
|
| -class ThrowExpression extends Expression {
|
| - /**
|
| - * The token representing the 'throw' keyword.
|
| - */
|
| - Token throwKeyword;
|
| -
|
| - /**
|
| - * The expression computing the exception to be thrown.
|
| - */
|
| - Expression _expression;
|
| -
|
| - /**
|
| - * Initialize a newly created throw expression.
|
| - */
|
| - ThrowExpression(this.throwKeyword, Expression expression) {
|
| - _expression = _becomeParentOf(expression);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => throwKeyword;
|
| -
|
| - @override
|
| - Iterable get childEntities =>
|
| - new ChildEntities()..add(throwKeyword)..add(_expression);
|
| -
|
| - @override
|
| - Token get endToken {
|
| - if (_expression != null) {
|
| - return _expression.endToken;
|
| - }
|
| - return throwKeyword;
|
| - }
|
| -
|
| - /**
|
| - * Return the expression computing the exception to be thrown.
|
| - */
|
| - Expression get expression => _expression;
|
| -
|
| - /**
|
| - * Set the expression computing the exception to be thrown to the given
|
| - * [expression].
|
| - */
|
| - void set expression(Expression expression) {
|
| - _expression = _becomeParentOf(expression);
|
| - }
|
| -
|
| - /**
|
| - * Return the token representing the 'throw' keyword.
|
| - */
|
| - @deprecated // Use "this.throwKeyword"
|
| - Token get keyword => throwKeyword;
|
| -
|
| - /**
|
| - * Set the token representing the 'throw' keyword to the given [token].
|
| - */
|
| - @deprecated // Use "this.throwKeyword"
|
| - set keyword(Token token) {
|
| - throwKeyword = token;
|
| - }
|
| -
|
| - @override
|
| - int get precedence => 0;
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitThrowExpression(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_expression, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * The declaration of one or more top-level variables of the same type.
|
| - *
|
| - * > topLevelVariableDeclaration ::=
|
| - * > ('final' | 'const') type? staticFinalDeclarationList ';'
|
| - * > | variableDeclaration ';'
|
| - */
|
| -class TopLevelVariableDeclaration extends CompilationUnitMember {
|
| - /**
|
| - * The top-level variables being declared.
|
| - */
|
| - VariableDeclarationList _variableList;
|
| -
|
| - /**
|
| - * The semicolon terminating the declaration.
|
| - */
|
| - Token semicolon;
|
| -
|
| - /**
|
| - * Initialize a newly created top-level variable declaration. Either or both
|
| - * of the [comment] and [metadata] can be `null` if the variable does not have
|
| - * the corresponding attribute.
|
| - */
|
| - TopLevelVariableDeclaration(Comment comment, List<Annotation> metadata,
|
| - VariableDeclarationList variableList, this.semicolon)
|
| - : super(comment, metadata) {
|
| - _variableList = _becomeParentOf(variableList);
|
| - }
|
| -
|
| - @override
|
| - Iterable get childEntities =>
|
| - super._childEntities..add(_variableList)..add(semicolon);
|
| -
|
| - @override
|
| - Element get element => null;
|
| -
|
| - @override
|
| - Token get endToken => semicolon;
|
| -
|
| - @override
|
| - Token get firstTokenAfterCommentAndMetadata => _variableList.beginToken;
|
| -
|
| - /**
|
| - * Return the top-level variables being declared.
|
| - */
|
| - VariableDeclarationList get variables => _variableList;
|
| -
|
| - /**
|
| - * Set the top-level variables being declared to the given list of
|
| - * [variables].
|
| - */
|
| - void set variables(VariableDeclarationList variables) {
|
| - _variableList = _becomeParentOf(variables);
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitTopLevelVariableDeclaration(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - super.visitChildren(visitor);
|
| - _safelyVisitChild(_variableList, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A visitor used to write a source representation of a visited AST node (and
|
| - * all of it's children) to a writer.
|
| - */
|
| -class ToSourceVisitor implements AstVisitor<Object> {
|
| - /**
|
| - * The writer to which the source is to be written.
|
| - */
|
| - final PrintWriter _writer;
|
| -
|
| - /**
|
| - * Initialize a newly created visitor to write source code representing the
|
| - * visited nodes to the given [writer].
|
| - */
|
| - ToSourceVisitor(this._writer);
|
| -
|
| - @override
|
| - Object visitAdjacentStrings(AdjacentStrings node) {
|
| - _visitNodeListWithSeparator(node.strings, " ");
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitAnnotation(Annotation node) {
|
| - _writer.print('@');
|
| - _visitNode(node.name);
|
| - _visitNodeWithPrefix(".", node.constructorName);
|
| - _visitNode(node.arguments);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitArgumentList(ArgumentList node) {
|
| - _writer.print('(');
|
| - _visitNodeListWithSeparator(node.arguments, ", ");
|
| - _writer.print(')');
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitAsExpression(AsExpression node) {
|
| - _visitNode(node.expression);
|
| - _writer.print(" as ");
|
| - _visitNode(node.type);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitAssertStatement(AssertStatement node) {
|
| - _writer.print("assert (");
|
| - _visitNode(node.condition);
|
| - _writer.print(");");
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitAssignmentExpression(AssignmentExpression node) {
|
| - _visitNode(node.leftHandSide);
|
| - _writer.print(' ');
|
| - _writer.print(node.operator.lexeme);
|
| - _writer.print(' ');
|
| - _visitNode(node.rightHandSide);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitAwaitExpression(AwaitExpression node) {
|
| - _writer.print("await ");
|
| - _visitNode(node.expression);
|
| - _writer.print(";");
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitBinaryExpression(BinaryExpression node) {
|
| - _visitNode(node.leftOperand);
|
| - _writer.print(' ');
|
| - _writer.print(node.operator.lexeme);
|
| - _writer.print(' ');
|
| - _visitNode(node.rightOperand);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitBlock(Block node) {
|
| - _writer.print('{');
|
| - _visitNodeListWithSeparator(node.statements, " ");
|
| - _writer.print('}');
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitBlockFunctionBody(BlockFunctionBody node) {
|
| - Token keyword = node.keyword;
|
| - if (keyword != null) {
|
| - _writer.print(keyword.lexeme);
|
| - if (node.star != null) {
|
| - _writer.print('*');
|
| - }
|
| - _writer.print(' ');
|
| - }
|
| - _visitNode(node.block);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitBooleanLiteral(BooleanLiteral node) {
|
| - _writer.print(node.literal.lexeme);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitBreakStatement(BreakStatement node) {
|
| - _writer.print("break");
|
| - _visitNodeWithPrefix(" ", node.label);
|
| - _writer.print(";");
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitCascadeExpression(CascadeExpression node) {
|
| - _visitNode(node.target);
|
| - _visitNodeList(node.cascadeSections);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitCatchClause(CatchClause node) {
|
| - _visitNodeWithPrefix("on ", node.exceptionType);
|
| - if (node.catchKeyword != null) {
|
| - if (node.exceptionType != null) {
|
| - _writer.print(' ');
|
| - }
|
| - _writer.print("catch (");
|
| - _visitNode(node.exceptionParameter);
|
| - _visitNodeWithPrefix(", ", node.stackTraceParameter);
|
| - _writer.print(") ");
|
| - } else {
|
| - _writer.print(" ");
|
| - }
|
| - _visitNode(node.body);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitClassDeclaration(ClassDeclaration node) {
|
| - _visitNodeListWithSeparatorAndSuffix(node.metadata, " ", " ");
|
| - _visitTokenWithSuffix(node.abstractKeyword, " ");
|
| - _writer.print("class ");
|
| - _visitNode(node.name);
|
| - _visitNode(node.typeParameters);
|
| - _visitNodeWithPrefix(" ", node.extendsClause);
|
| - _visitNodeWithPrefix(" ", node.withClause);
|
| - _visitNodeWithPrefix(" ", node.implementsClause);
|
| - _writer.print(" {");
|
| - _visitNodeListWithSeparator(node.members, " ");
|
| - _writer.print("}");
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitClassTypeAlias(ClassTypeAlias node) {
|
| - _visitNodeListWithSeparatorAndSuffix(node.metadata, " ", " ");
|
| - if (node.abstractKeyword != null) {
|
| - _writer.print("abstract ");
|
| - }
|
| - _writer.print("class ");
|
| - _visitNode(node.name);
|
| - _visitNode(node.typeParameters);
|
| - _writer.print(" = ");
|
| - _visitNode(node.superclass);
|
| - _visitNodeWithPrefix(" ", node.withClause);
|
| - _visitNodeWithPrefix(" ", node.implementsClause);
|
| - _writer.print(";");
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitComment(Comment node) => null;
|
| -
|
| - @override
|
| - Object visitCommentReference(CommentReference node) => null;
|
| -
|
| - @override
|
| - Object visitCompilationUnit(CompilationUnit node) {
|
| - ScriptTag scriptTag = node.scriptTag;
|
| - NodeList<Directive> directives = node.directives;
|
| - _visitNode(scriptTag);
|
| - String prefix = scriptTag == null ? "" : " ";
|
| - _visitNodeListWithSeparatorAndPrefix(prefix, directives, " ");
|
| - prefix = scriptTag == null && directives.isEmpty ? "" : " ";
|
| - _visitNodeListWithSeparatorAndPrefix(prefix, node.declarations, " ");
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitConditionalExpression(ConditionalExpression node) {
|
| - _visitNode(node.condition);
|
| - _writer.print(" ? ");
|
| - _visitNode(node.thenExpression);
|
| - _writer.print(" : ");
|
| - _visitNode(node.elseExpression);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitConstructorDeclaration(ConstructorDeclaration node) {
|
| - _visitNodeListWithSeparatorAndSuffix(node.metadata, " ", " ");
|
| - _visitTokenWithSuffix(node.externalKeyword, " ");
|
| - _visitTokenWithSuffix(node.constKeyword, " ");
|
| - _visitTokenWithSuffix(node.factoryKeyword, " ");
|
| - _visitNode(node.returnType);
|
| - _visitNodeWithPrefix(".", node.name);
|
| - _visitNode(node.parameters);
|
| - _visitNodeListWithSeparatorAndPrefix(" : ", node.initializers, ", ");
|
| - _visitNodeWithPrefix(" = ", node.redirectedConstructor);
|
| - _visitFunctionWithPrefix(" ", node.body);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
|
| - _visitTokenWithSuffix(node.thisKeyword, ".");
|
| - _visitNode(node.fieldName);
|
| - _writer.print(" = ");
|
| - _visitNode(node.expression);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitConstructorName(ConstructorName node) {
|
| - _visitNode(node.type);
|
| - _visitNodeWithPrefix(".", node.name);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitContinueStatement(ContinueStatement node) {
|
| - _writer.print("continue");
|
| - _visitNodeWithPrefix(" ", node.label);
|
| - _writer.print(";");
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitDeclaredIdentifier(DeclaredIdentifier node) {
|
| - _visitNodeListWithSeparatorAndSuffix(node.metadata, " ", " ");
|
| - _visitTokenWithSuffix(node.keyword, " ");
|
| - _visitNodeWithSuffix(node.type, " ");
|
| - _visitNode(node.identifier);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitDefaultFormalParameter(DefaultFormalParameter node) {
|
| - _visitNode(node.parameter);
|
| - if (node.separator != null) {
|
| - _writer.print(" ");
|
| - _writer.print(node.separator.lexeme);
|
| - _visitNodeWithPrefix(" ", node.defaultValue);
|
| - }
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitDoStatement(DoStatement node) {
|
| - _writer.print("do ");
|
| - _visitNode(node.body);
|
| - _writer.print(" while (");
|
| - _visitNode(node.condition);
|
| - _writer.print(");");
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitDoubleLiteral(DoubleLiteral node) {
|
| - _writer.print(node.literal.lexeme);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitEmptyFunctionBody(EmptyFunctionBody node) {
|
| - _writer.print(';');
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitEmptyStatement(EmptyStatement node) {
|
| - _writer.print(';');
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitEnumConstantDeclaration(EnumConstantDeclaration node) {
|
| - _visitNodeListWithSeparatorAndSuffix(node.metadata, " ", " ");
|
| - _visitNode(node.name);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitEnumDeclaration(EnumDeclaration node) {
|
| - _visitNodeListWithSeparatorAndSuffix(node.metadata, " ", " ");
|
| - _writer.print("enum ");
|
| - _visitNode(node.name);
|
| - _writer.print(" {");
|
| - _visitNodeListWithSeparator(node.constants, ", ");
|
| - _writer.print("}");
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitExportDirective(ExportDirective node) {
|
| - _visitNodeListWithSeparatorAndSuffix(node.metadata, " ", " ");
|
| - _writer.print("export ");
|
| - _visitNode(node.uri);
|
| - _visitNodeListWithSeparatorAndPrefix(" ", node.combinators, " ");
|
| - _writer.print(';');
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitExpressionFunctionBody(ExpressionFunctionBody node) {
|
| - Token keyword = node.keyword;
|
| - if (keyword != null) {
|
| - _writer.print(keyword.lexeme);
|
| - _writer.print(' ');
|
| - }
|
| - _writer.print("=> ");
|
| - _visitNode(node.expression);
|
| - if (node.semicolon != null) {
|
| - _writer.print(';');
|
| - }
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitExpressionStatement(ExpressionStatement node) {
|
| - _visitNode(node.expression);
|
| - _writer.print(';');
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitExtendsClause(ExtendsClause node) {
|
| - _writer.print("extends ");
|
| - _visitNode(node.superclass);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitFieldDeclaration(FieldDeclaration node) {
|
| - _visitNodeListWithSeparatorAndSuffix(node.metadata, " ", " ");
|
| - _visitTokenWithSuffix(node.staticKeyword, " ");
|
| - _visitNode(node.fields);
|
| - _writer.print(";");
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitFieldFormalParameter(FieldFormalParameter node) {
|
| - _visitTokenWithSuffix(node.keyword, " ");
|
| - _visitNodeWithSuffix(node.type, " ");
|
| - _writer.print("this.");
|
| - _visitNode(node.identifier);
|
| - _visitNode(node.typeParameters);
|
| - _visitNode(node.parameters);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitForEachStatement(ForEachStatement node) {
|
| - DeclaredIdentifier loopVariable = node.loopVariable;
|
| - if (node.awaitKeyword != null) {
|
| - _writer.print("await ");
|
| - }
|
| - _writer.print("for (");
|
| - if (loopVariable == null) {
|
| - _visitNode(node.identifier);
|
| - } else {
|
| - _visitNode(loopVariable);
|
| - }
|
| - _writer.print(" in ");
|
| - _visitNode(node.iterable);
|
| - _writer.print(") ");
|
| - _visitNode(node.body);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitFormalParameterList(FormalParameterList node) {
|
| - String groupEnd = null;
|
| - _writer.print('(');
|
| - NodeList<FormalParameter> parameters = node.parameters;
|
| - int size = parameters.length;
|
| - for (int i = 0; i < size; i++) {
|
| - FormalParameter parameter = parameters[i];
|
| - if (i > 0) {
|
| - _writer.print(", ");
|
| - }
|
| - if (groupEnd == null && parameter is DefaultFormalParameter) {
|
| - if (parameter.kind == ParameterKind.NAMED) {
|
| - groupEnd = "}";
|
| - _writer.print('{');
|
| - } else {
|
| - groupEnd = "]";
|
| - _writer.print('[');
|
| - }
|
| - }
|
| - parameter.accept(this);
|
| - }
|
| - if (groupEnd != null) {
|
| - _writer.print(groupEnd);
|
| - }
|
| - _writer.print(')');
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitForStatement(ForStatement node) {
|
| - Expression initialization = node.initialization;
|
| - _writer.print("for (");
|
| - if (initialization != null) {
|
| - _visitNode(initialization);
|
| - } else {
|
| - _visitNode(node.variables);
|
| - }
|
| - _writer.print(";");
|
| - _visitNodeWithPrefix(" ", node.condition);
|
| - _writer.print(";");
|
| - _visitNodeListWithSeparatorAndPrefix(" ", node.updaters, ", ");
|
| - _writer.print(") ");
|
| - _visitNode(node.body);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitFunctionDeclaration(FunctionDeclaration node) {
|
| - _visitNodeListWithSeparatorAndSuffix(node.metadata, " ", " ");
|
| - _visitNodeWithSuffix(node.returnType, " ");
|
| - _visitTokenWithSuffix(node.propertyKeyword, " ");
|
| - _visitNode(node.name);
|
| - _visitNode(node.functionExpression);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitFunctionDeclarationStatement(FunctionDeclarationStatement node) {
|
| - _visitNode(node.functionDeclaration);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitFunctionExpression(FunctionExpression node) {
|
| - _visitNode(node.typeParameters);
|
| - _visitNode(node.parameters);
|
| - _writer.print(' ');
|
| - _visitNode(node.body);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
|
| - _visitNode(node.function);
|
| - _visitNode(node.typeArguments);
|
| - _visitNode(node.argumentList);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitFunctionTypeAlias(FunctionTypeAlias node) {
|
| - _visitNodeListWithSeparatorAndSuffix(node.metadata, " ", " ");
|
| - _writer.print("typedef ");
|
| - _visitNodeWithSuffix(node.returnType, " ");
|
| - _visitNode(node.name);
|
| - _visitNode(node.typeParameters);
|
| - _visitNode(node.parameters);
|
| - _writer.print(";");
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
|
| - _visitNodeWithSuffix(node.returnType, " ");
|
| - _visitNode(node.identifier);
|
| - _visitNode(node.typeParameters);
|
| - _visitNode(node.parameters);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitHideCombinator(HideCombinator node) {
|
| - _writer.print("hide ");
|
| - _visitNodeListWithSeparator(node.hiddenNames, ", ");
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitIfStatement(IfStatement node) {
|
| - _writer.print("if (");
|
| - _visitNode(node.condition);
|
| - _writer.print(") ");
|
| - _visitNode(node.thenStatement);
|
| - _visitNodeWithPrefix(" else ", node.elseStatement);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitImplementsClause(ImplementsClause node) {
|
| - _writer.print("implements ");
|
| - _visitNodeListWithSeparator(node.interfaces, ", ");
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitImportDirective(ImportDirective node) {
|
| - _visitNodeListWithSeparatorAndSuffix(node.metadata, " ", " ");
|
| - _writer.print("import ");
|
| - _visitNode(node.uri);
|
| - if (node.deferredKeyword != null) {
|
| - _writer.print(" deferred");
|
| - }
|
| - _visitNodeWithPrefix(" as ", node.prefix);
|
| - _visitNodeListWithSeparatorAndPrefix(" ", node.combinators, " ");
|
| - _writer.print(';');
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitIndexExpression(IndexExpression node) {
|
| - if (node.isCascaded) {
|
| - _writer.print("..");
|
| - } else {
|
| - _visitNode(node.target);
|
| - }
|
| - _writer.print('[');
|
| - _visitNode(node.index);
|
| - _writer.print(']');
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitInstanceCreationExpression(InstanceCreationExpression node) {
|
| - _visitTokenWithSuffix(node.keyword, " ");
|
| - _visitNode(node.constructorName);
|
| - _visitNode(node.argumentList);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitIntegerLiteral(IntegerLiteral node) {
|
| - _writer.print(node.literal.lexeme);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitInterpolationExpression(InterpolationExpression node) {
|
| - if (node.rightBracket != null) {
|
| - _writer.print("\${");
|
| - _visitNode(node.expression);
|
| - _writer.print("}");
|
| - } else {
|
| - _writer.print("\$");
|
| - _visitNode(node.expression);
|
| - }
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitInterpolationString(InterpolationString node) {
|
| - _writer.print(node.contents.lexeme);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitIsExpression(IsExpression node) {
|
| - _visitNode(node.expression);
|
| - if (node.notOperator == null) {
|
| - _writer.print(" is ");
|
| - } else {
|
| - _writer.print(" is! ");
|
| - }
|
| - _visitNode(node.type);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitLabel(Label node) {
|
| - _visitNode(node.label);
|
| - _writer.print(":");
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitLabeledStatement(LabeledStatement node) {
|
| - _visitNodeListWithSeparatorAndSuffix(node.labels, " ", " ");
|
| - _visitNode(node.statement);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitLibraryDirective(LibraryDirective node) {
|
| - _visitNodeListWithSeparatorAndSuffix(node.metadata, " ", " ");
|
| - _writer.print("library ");
|
| - _visitNode(node.name);
|
| - _writer.print(';');
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitLibraryIdentifier(LibraryIdentifier node) {
|
| - _writer.print(node.name);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitListLiteral(ListLiteral node) {
|
| - if (node.constKeyword != null) {
|
| - _writer.print(node.constKeyword.lexeme);
|
| - _writer.print(' ');
|
| - }
|
| - _visitNodeWithSuffix(node.typeArguments, " ");
|
| - _writer.print("[");
|
| - _visitNodeListWithSeparator(node.elements, ", ");
|
| - _writer.print("]");
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitMapLiteral(MapLiteral node) {
|
| - if (node.constKeyword != null) {
|
| - _writer.print(node.constKeyword.lexeme);
|
| - _writer.print(' ');
|
| - }
|
| - _visitNodeWithSuffix(node.typeArguments, " ");
|
| - _writer.print("{");
|
| - _visitNodeListWithSeparator(node.entries, ", ");
|
| - _writer.print("}");
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitMapLiteralEntry(MapLiteralEntry node) {
|
| - _visitNode(node.key);
|
| - _writer.print(" : ");
|
| - _visitNode(node.value);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitMethodDeclaration(MethodDeclaration node) {
|
| - _visitNodeListWithSeparatorAndSuffix(node.metadata, " ", " ");
|
| - _visitTokenWithSuffix(node.externalKeyword, " ");
|
| - _visitTokenWithSuffix(node.modifierKeyword, " ");
|
| - _visitNodeWithSuffix(node.returnType, " ");
|
| - _visitTokenWithSuffix(node.propertyKeyword, " ");
|
| - _visitTokenWithSuffix(node.operatorKeyword, " ");
|
| - _visitNode(node.name);
|
| - if (!node.isGetter) {
|
| - _visitNode(node.typeParameters);
|
| - _visitNode(node.parameters);
|
| - }
|
| - _visitFunctionWithPrefix(" ", node.body);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitMethodInvocation(MethodInvocation node) {
|
| - if (node.isCascaded) {
|
| - _writer.print("..");
|
| - } else {
|
| - if (node.target != null) {
|
| - node.target.accept(this);
|
| - _writer.print(node.operator.lexeme);
|
| - }
|
| - }
|
| - _visitNode(node.methodName);
|
| - _visitNode(node.typeArguments);
|
| - _visitNode(node.argumentList);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitNamedExpression(NamedExpression node) {
|
| - _visitNode(node.name);
|
| - _visitNodeWithPrefix(" ", node.expression);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitNativeClause(NativeClause node) {
|
| - _writer.print("native ");
|
| - _visitNode(node.name);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitNativeFunctionBody(NativeFunctionBody node) {
|
| - _writer.print("native ");
|
| - _visitNode(node.stringLiteral);
|
| - _writer.print(';');
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitNullLiteral(NullLiteral node) {
|
| - _writer.print("null");
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitParenthesizedExpression(ParenthesizedExpression node) {
|
| - _writer.print('(');
|
| - _visitNode(node.expression);
|
| - _writer.print(')');
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitPartDirective(PartDirective node) {
|
| - _visitNodeListWithSeparatorAndSuffix(node.metadata, " ", " ");
|
| - _writer.print("part ");
|
| - _visitNode(node.uri);
|
| - _writer.print(';');
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitPartOfDirective(PartOfDirective node) {
|
| - _visitNodeListWithSeparatorAndSuffix(node.metadata, " ", " ");
|
| - _writer.print("part of ");
|
| - _visitNode(node.libraryName);
|
| - _writer.print(';');
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitPostfixExpression(PostfixExpression node) {
|
| - _visitNode(node.operand);
|
| - _writer.print(node.operator.lexeme);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitPrefixedIdentifier(PrefixedIdentifier node) {
|
| - _visitNode(node.prefix);
|
| - _writer.print('.');
|
| - _visitNode(node.identifier);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitPrefixExpression(PrefixExpression node) {
|
| - _writer.print(node.operator.lexeme);
|
| - _visitNode(node.operand);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitPropertyAccess(PropertyAccess node) {
|
| - if (node.isCascaded) {
|
| - _writer.print("..");
|
| - } else {
|
| - _visitNode(node.target);
|
| - _writer.print(node.operator.lexeme);
|
| - }
|
| - _visitNode(node.propertyName);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitRedirectingConstructorInvocation(
|
| - RedirectingConstructorInvocation node) {
|
| - _writer.print("this");
|
| - _visitNodeWithPrefix(".", node.constructorName);
|
| - _visitNode(node.argumentList);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitRethrowExpression(RethrowExpression node) {
|
| - _writer.print("rethrow");
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitReturnStatement(ReturnStatement node) {
|
| - Expression expression = node.expression;
|
| - if (expression == null) {
|
| - _writer.print("return;");
|
| - } else {
|
| - _writer.print("return ");
|
| - expression.accept(this);
|
| - _writer.print(";");
|
| - }
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitScriptTag(ScriptTag node) {
|
| - _writer.print(node.scriptTag.lexeme);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitShowCombinator(ShowCombinator node) {
|
| - _writer.print("show ");
|
| - _visitNodeListWithSeparator(node.shownNames, ", ");
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitSimpleFormalParameter(SimpleFormalParameter node) {
|
| - _visitTokenWithSuffix(node.keyword, " ");
|
| - _visitNodeWithSuffix(node.type, " ");
|
| - _visitNode(node.identifier);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitSimpleIdentifier(SimpleIdentifier node) {
|
| - _writer.print(node.token.lexeme);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitSimpleStringLiteral(SimpleStringLiteral node) {
|
| - _writer.print(node.literal.lexeme);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitStringInterpolation(StringInterpolation node) {
|
| - _visitNodeList(node.elements);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitSuperConstructorInvocation(SuperConstructorInvocation node) {
|
| - _writer.print("super");
|
| - _visitNodeWithPrefix(".", node.constructorName);
|
| - _visitNode(node.argumentList);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitSuperExpression(SuperExpression node) {
|
| - _writer.print("super");
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitSwitchCase(SwitchCase node) {
|
| - _visitNodeListWithSeparatorAndSuffix(node.labels, " ", " ");
|
| - _writer.print("case ");
|
| - _visitNode(node.expression);
|
| - _writer.print(": ");
|
| - _visitNodeListWithSeparator(node.statements, " ");
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitSwitchDefault(SwitchDefault node) {
|
| - _visitNodeListWithSeparatorAndSuffix(node.labels, " ", " ");
|
| - _writer.print("default: ");
|
| - _visitNodeListWithSeparator(node.statements, " ");
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitSwitchStatement(SwitchStatement node) {
|
| - _writer.print("switch (");
|
| - _visitNode(node.expression);
|
| - _writer.print(") {");
|
| - _visitNodeListWithSeparator(node.members, " ");
|
| - _writer.print("}");
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitSymbolLiteral(SymbolLiteral node) {
|
| - _writer.print("#");
|
| - List<Token> components = node.components;
|
| - for (int i = 0; i < components.length; i++) {
|
| - if (i > 0) {
|
| - _writer.print(".");
|
| - }
|
| - _writer.print(components[i].lexeme);
|
| - }
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitThisExpression(ThisExpression node) {
|
| - _writer.print("this");
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitThrowExpression(ThrowExpression node) {
|
| - _writer.print("throw ");
|
| - _visitNode(node.expression);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
|
| - _visitNodeWithSuffix(node.variables, ";");
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitTryStatement(TryStatement node) {
|
| - _writer.print("try ");
|
| - _visitNode(node.body);
|
| - _visitNodeListWithSeparatorAndPrefix(" ", node.catchClauses, " ");
|
| - _visitNodeWithPrefix(" finally ", node.finallyBlock);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitTypeArgumentList(TypeArgumentList node) {
|
| - _writer.print('<');
|
| - _visitNodeListWithSeparator(node.arguments, ", ");
|
| - _writer.print('>');
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitTypeName(TypeName node) {
|
| - _visitNode(node.name);
|
| - _visitNode(node.typeArguments);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitTypeParameter(TypeParameter node) {
|
| - _visitNodeListWithSeparatorAndSuffix(node.metadata, " ", " ");
|
| - _visitNode(node.name);
|
| - _visitNodeWithPrefix(" extends ", node.bound);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitTypeParameterList(TypeParameterList node) {
|
| - _writer.print('<');
|
| - _visitNodeListWithSeparator(node.typeParameters, ", ");
|
| - _writer.print('>');
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitVariableDeclaration(VariableDeclaration node) {
|
| - _visitNodeListWithSeparatorAndSuffix(node.metadata, " ", " ");
|
| - _visitNode(node.name);
|
| - _visitNodeWithPrefix(" = ", node.initializer);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitVariableDeclarationList(VariableDeclarationList node) {
|
| - _visitNodeListWithSeparatorAndSuffix(node.metadata, " ", " ");
|
| - _visitTokenWithSuffix(node.keyword, " ");
|
| - _visitNodeWithSuffix(node.type, " ");
|
| - _visitNodeListWithSeparator(node.variables, ", ");
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitVariableDeclarationStatement(VariableDeclarationStatement node) {
|
| - _visitNode(node.variables);
|
| - _writer.print(";");
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitWhileStatement(WhileStatement node) {
|
| - _writer.print("while (");
|
| - _visitNode(node.condition);
|
| - _writer.print(") ");
|
| - _visitNode(node.body);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitWithClause(WithClause node) {
|
| - _writer.print("with ");
|
| - _visitNodeListWithSeparator(node.mixinTypes, ", ");
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitYieldStatement(YieldStatement node) {
|
| - if (node.star != null) {
|
| - _writer.print("yield* ");
|
| - } else {
|
| - _writer.print("yield ");
|
| - }
|
| - _visitNode(node.expression);
|
| - _writer.print(";");
|
| - return null;
|
| - }
|
| -
|
| - /**
|
| - * Visit the given function [body], printing the [prefix] before if the body
|
| - * is not empty.
|
| - */
|
| - void _visitFunctionWithPrefix(String prefix, FunctionBody body) {
|
| - if (body is! EmptyFunctionBody) {
|
| - _writer.print(prefix);
|
| - }
|
| - _visitNode(body);
|
| - }
|
| -
|
| - /**
|
| - * Safely visit the given [node].
|
| - */
|
| - void _visitNode(AstNode node) {
|
| - if (node != null) {
|
| - node.accept(this);
|
| - }
|
| - }
|
| -
|
| - /**
|
| - * Print a list of [nodes] without any separation.
|
| - */
|
| - void _visitNodeList(NodeList<AstNode> nodes) {
|
| - _visitNodeListWithSeparator(nodes, "");
|
| - }
|
| -
|
| - /**
|
| - * Print a list of [nodes], separated by the given [separator].
|
| - */
|
| - void _visitNodeListWithSeparator(NodeList<AstNode> nodes, String separator) {
|
| - if (nodes != null) {
|
| - int size = nodes.length;
|
| - for (int i = 0; i < size; i++) {
|
| - if (i > 0) {
|
| - _writer.print(separator);
|
| - }
|
| - nodes[i].accept(this);
|
| - }
|
| - }
|
| - }
|
| -
|
| - /**
|
| - * Print a list of [nodes], prefixed by the given [prefix] if the list is not
|
| - * empty, and separated by the given [separator].
|
| - */
|
| - void _visitNodeListWithSeparatorAndPrefix(
|
| - String prefix, NodeList<AstNode> nodes, String separator) {
|
| - if (nodes != null) {
|
| - int size = nodes.length;
|
| - if (size > 0) {
|
| - _writer.print(prefix);
|
| - for (int i = 0; i < size; i++) {
|
| - if (i > 0) {
|
| - _writer.print(separator);
|
| - }
|
| - nodes[i].accept(this);
|
| - }
|
| - }
|
| - }
|
| - }
|
| -
|
| - /**
|
| - * Print a list of [nodes], separated by the given [separator], followed by
|
| - * the given [suffix] if the list is not empty.
|
| - */
|
| - void _visitNodeListWithSeparatorAndSuffix(
|
| - NodeList<AstNode> nodes, String separator, String suffix) {
|
| - if (nodes != null) {
|
| - int size = nodes.length;
|
| - if (size > 0) {
|
| - for (int i = 0; i < size; i++) {
|
| - if (i > 0) {
|
| - _writer.print(separator);
|
| - }
|
| - nodes[i].accept(this);
|
| - }
|
| - _writer.print(suffix);
|
| - }
|
| - }
|
| - }
|
| -
|
| - /**
|
| - * Safely visit the given [node], printing the [prefix] before the node if it
|
| - * is non-`null`.
|
| - */
|
| - void _visitNodeWithPrefix(String prefix, AstNode node) {
|
| - if (node != null) {
|
| - _writer.print(prefix);
|
| - node.accept(this);
|
| - }
|
| - }
|
| -
|
| - /**
|
| - * Safely visit the given [node], printing the [suffix] after the node if it
|
| - * is non-`null`.
|
| - */
|
| - void _visitNodeWithSuffix(AstNode node, String suffix) {
|
| - if (node != null) {
|
| - node.accept(this);
|
| - _writer.print(suffix);
|
| - }
|
| - }
|
| -
|
| - /**
|
| - * Safely visit the given [token], printing the [suffix] after the token if it
|
| - * is non-`null`.
|
| - */
|
| - void _visitTokenWithSuffix(Token token, String suffix) {
|
| - if (token != null) {
|
| - _writer.print(token.lexeme);
|
| - _writer.print(suffix);
|
| - }
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A try statement.
|
| - *
|
| - * > tryStatement ::=
|
| - * > 'try' [Block] ([CatchClause]+ finallyClause? | finallyClause)
|
| - * >
|
| - * > finallyClause ::=
|
| - * > 'finally' [Block]
|
| - */
|
| -class TryStatement extends Statement {
|
| - /**
|
| - * The token representing the 'try' keyword.
|
| - */
|
| - Token tryKeyword;
|
| -
|
| - /**
|
| - * The body of the statement.
|
| - */
|
| - Block _body;
|
| -
|
| - /**
|
| - * The catch clauses contained in the try statement.
|
| - */
|
| - NodeList<CatchClause> _catchClauses;
|
| -
|
| - /**
|
| - * The token representing the 'finally' keyword, or `null` if the statement
|
| - * does not contain a finally clause.
|
| - */
|
| - Token finallyKeyword;
|
| -
|
| - /**
|
| - * The finally block contained in the try statement, or `null` if the
|
| - * statement does not contain a finally clause.
|
| - */
|
| - Block _finallyBlock;
|
| -
|
| - /**
|
| - * Initialize a newly created try statement. The list of [catchClauses] can be
|
| - * `null` if there are no catch clauses. The [finallyKeyword] and
|
| - * [finallyBlock] can be `null` if there is no finally clause.
|
| - */
|
| - TryStatement(this.tryKeyword, Block body, List<CatchClause> catchClauses,
|
| - this.finallyKeyword, Block finallyBlock) {
|
| - _body = _becomeParentOf(body);
|
| - _catchClauses = new NodeList<CatchClause>(this, catchClauses);
|
| - _finallyBlock = _becomeParentOf(finallyBlock);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => tryKeyword;
|
| -
|
| - /**
|
| - * Return the body of the statement.
|
| - */
|
| - Block get body => _body;
|
| -
|
| - /**
|
| - * Set the body of the statement to the given [block].
|
| - */
|
| - void set body(Block block) {
|
| - _body = _becomeParentOf(block);
|
| - }
|
| -
|
| - /**
|
| - * Return the catch clauses contained in the try statement.
|
| - */
|
| - NodeList<CatchClause> get catchClauses => _catchClauses;
|
| -
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()
|
| - ..add(tryKeyword)
|
| - ..add(_body)
|
| - ..addAll(_catchClauses)
|
| - ..add(finallyKeyword)
|
| - ..add(_finallyBlock);
|
| -
|
| - @override
|
| - Token get endToken {
|
| - if (_finallyBlock != null) {
|
| - return _finallyBlock.endToken;
|
| - } else if (finallyKeyword != null) {
|
| - return finallyKeyword;
|
| - } else if (!_catchClauses.isEmpty) {
|
| - return _catchClauses.endToken;
|
| - }
|
| - return _body.endToken;
|
| - }
|
| -
|
| - /**
|
| - * Return the finally block contained in the try statement, or `null` if the
|
| - * statement does not contain a finally clause.
|
| - */
|
| - Block get finallyBlock => _finallyBlock;
|
| -
|
| - /**
|
| - * Set the finally block contained in the try statement to the given [block].
|
| - */
|
| - void set finallyBlock(Block block) {
|
| - _finallyBlock = _becomeParentOf(block);
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitTryStatement(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_body, visitor);
|
| - _catchClauses.accept(visitor);
|
| - _safelyVisitChild(_finallyBlock, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * The declaration of a type alias.
|
| - *
|
| - * > typeAlias ::=
|
| - * > 'typedef' typeAliasBody
|
| - * >
|
| - * > typeAliasBody ::=
|
| - * > classTypeAlias
|
| - * > | functionTypeAlias
|
| - */
|
| -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,
|
| - 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.
|
| - */
|
| - @deprecated // Use "this.typedefKeyword"
|
| - Token get keyword => typedefKeyword;
|
| -
|
| - /**
|
| - * Set the token representing the 'typedef' keyword to the given [token].
|
| - */
|
| - @deprecated // Use "this.typedefKeyword"
|
| - set keyword(Token token) {
|
| - typedefKeyword = token;
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A list of type arguments.
|
| - *
|
| - * > typeArguments ::=
|
| - * > '<' typeName (',' typeName)* '>'
|
| - */
|
| -class TypeArgumentList extends AstNode {
|
| - /**
|
| - * The left bracket.
|
| - */
|
| - Token leftBracket;
|
| -
|
| - /**
|
| - * The type arguments associated with the type.
|
| - */
|
| - NodeList<TypeName> _arguments;
|
| -
|
| - /**
|
| - * The right bracket.
|
| - */
|
| - Token rightBracket;
|
| -
|
| - /**
|
| - * Initialize a newly created list of type arguments.
|
| - */
|
| - TypeArgumentList(
|
| - this.leftBracket, List<TypeName> arguments, this.rightBracket) {
|
| - _arguments = new NodeList<TypeName>(this, arguments);
|
| - }
|
| -
|
| - /**
|
| - * Return the type arguments associated with the type.
|
| - */
|
| - NodeList<TypeName> get arguments => _arguments;
|
| -
|
| - @override
|
| - Token get beginToken => leftBracket;
|
| -
|
| - /**
|
| - * TODO(paulberry): Add commas.
|
| - */
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()
|
| - ..add(leftBracket)
|
| - ..addAll(_arguments)
|
| - ..add(rightBracket);
|
| -
|
| - @override
|
| - Token get endToken => rightBracket;
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitTypeArgumentList(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _arguments.accept(visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A literal that has a type associated with it.
|
| - *
|
| - * > typedLiteral ::=
|
| - * > [ListLiteral]
|
| - * > | [MapLiteral]
|
| - */
|
| -abstract class TypedLiteral extends Literal {
|
| - /**
|
| - * The token representing the 'const' keyword, or `null` if the literal is not
|
| - * a constant.
|
| - */
|
| - Token constKeyword;
|
| -
|
| - /**
|
| - * The type argument associated with this literal, or `null` if no type
|
| - * arguments were declared.
|
| - */
|
| - TypeArgumentList _typeArguments;
|
| -
|
| - /**
|
| - * Initialize a newly created typed literal. The [constKeyword] can be `null`\
|
| - * if the literal is not a constant. The [typeArguments] can be `null` if no
|
| - * type arguments were declared.
|
| - */
|
| - TypedLiteral(this.constKeyword, TypeArgumentList typeArguments) {
|
| - _typeArguments = _becomeParentOf(typeArguments);
|
| - }
|
| -
|
| - /**
|
| - * Return the type argument associated with this literal, or `null` if no type
|
| - * arguments were declared.
|
| - */
|
| - TypeArgumentList get typeArguments => _typeArguments;
|
| -
|
| - /**
|
| - * Set the type argument associated with this literal to the given
|
| - * [typeArguments].
|
| - */
|
| - void set typeArguments(TypeArgumentList typeArguments) {
|
| - _typeArguments = _becomeParentOf(typeArguments);
|
| - }
|
| -
|
| - ChildEntities get _childEntities =>
|
| - new ChildEntities()..add(constKeyword)..add(_typeArguments);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_typeArguments, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * The name of a type, which can optionally include type arguments.
|
| - *
|
| - * > typeName ::=
|
| - * > [Identifier] typeArguments?
|
| - */
|
| -class TypeName extends AstNode {
|
| - /**
|
| - * The name of the type.
|
| - */
|
| - Identifier _name;
|
| -
|
| - /**
|
| - * The type arguments associated with the type, or `null` if there are no type
|
| - * arguments.
|
| - */
|
| - TypeArgumentList _typeArguments;
|
| -
|
| - /**
|
| - * The type being named, or `null` if the AST structure has not been resolved.
|
| - */
|
| - DartType type;
|
| -
|
| - /**
|
| - * Initialize a newly created type name. The [typeArguments] can be `null` if
|
| - * there are no type arguments.
|
| - */
|
| - TypeName(Identifier name, TypeArgumentList typeArguments) {
|
| - _name = _becomeParentOf(name);
|
| - _typeArguments = _becomeParentOf(typeArguments);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => _name.beginToken;
|
| -
|
| - @override
|
| - Iterable get childEntities =>
|
| - new ChildEntities()..add(_name)..add(_typeArguments);
|
| -
|
| - @override
|
| - Token get endToken {
|
| - if (_typeArguments != null) {
|
| - return _typeArguments.endToken;
|
| - }
|
| - return _name.endToken;
|
| - }
|
| -
|
| - /**
|
| - * Return `true` if this type is a deferred type.
|
| - *
|
| - * 15.1 Static Types: A type <i>T</i> is deferred iff it is of the form
|
| - * </i>p.T</i> where <i>p</i> is a deferred prefix.
|
| - */
|
| - bool get isDeferred {
|
| - Identifier identifier = name;
|
| - if (identifier is! PrefixedIdentifier) {
|
| - return false;
|
| - }
|
| - return (identifier as PrefixedIdentifier).isDeferred;
|
| - }
|
| -
|
| - @override
|
| - bool get isSynthetic => _name.isSynthetic && _typeArguments == null;
|
| -
|
| - /**
|
| - * Return the name of the type.
|
| - */
|
| - Identifier get name => _name;
|
| -
|
| - /**
|
| - * Set the name of the type to the given [identifier].
|
| - */
|
| - void set name(Identifier identifier) {
|
| - _name = _becomeParentOf(identifier);
|
| - }
|
| -
|
| - /**
|
| - * Return the type arguments associated with the type, or `null` if there are
|
| - * no type arguments.
|
| - */
|
| - TypeArgumentList get typeArguments => _typeArguments;
|
| -
|
| - /**
|
| - * Set the type arguments associated with the type to the given
|
| - * [typeArguments].
|
| - */
|
| - void set typeArguments(TypeArgumentList typeArguments) {
|
| - _typeArguments = _becomeParentOf(typeArguments);
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitTypeName(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_name, visitor);
|
| - _safelyVisitChild(_typeArguments, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A type parameter.
|
| - *
|
| - * > typeParameter ::=
|
| - * > [SimpleIdentifier] ('extends' [TypeName])?
|
| - */
|
| -class TypeParameter extends Declaration {
|
| - /**
|
| - * The name of the type parameter.
|
| - */
|
| - SimpleIdentifier _name;
|
| -
|
| - /**
|
| - * The token representing the 'extends' keyword, or `null` if there is no
|
| - * explicit upper bound.
|
| - */
|
| - Token extendsKeyword;
|
| -
|
| - /**
|
| - * The name of the upper bound for legal arguments, or `null` if there is no
|
| - * explicit upper bound.
|
| - */
|
| - TypeName _bound;
|
| -
|
| - /**
|
| - * Initialize a newly created type parameter. Either or both of the [comment]
|
| - * and [metadata] can be `null` if the parameter does not have the
|
| - * corresponding attribute. The [extendsKeyword] and [bound] can be `null` if
|
| - * the parameter does not have an upper bound.
|
| - */
|
| - TypeParameter(Comment comment, List<Annotation> metadata,
|
| - SimpleIdentifier name, this.extendsKeyword, TypeName bound)
|
| - : super(comment, metadata) {
|
| - _name = _becomeParentOf(name);
|
| - _bound = _becomeParentOf(bound);
|
| - }
|
| -
|
| - /**
|
| - * Return the name of the upper bound for legal arguments, or `null` if there
|
| - * is no explicit upper bound.
|
| - */
|
| - TypeName get bound => _bound;
|
| -
|
| - /**
|
| - * Set the name of the upper bound for legal arguments to the given
|
| - * [typeName].
|
| - */
|
| - void set bound(TypeName typeName) {
|
| - _bound = _becomeParentOf(typeName);
|
| - }
|
| -
|
| - @override
|
| - Iterable get childEntities =>
|
| - super._childEntities..add(_name)..add(extendsKeyword)..add(_bound);
|
| -
|
| - @override
|
| - TypeParameterElement get element =>
|
| - _name != null ? (_name.staticElement as TypeParameterElement) : null;
|
| -
|
| - @override
|
| - Token get endToken {
|
| - if (_bound == null) {
|
| - return _name.endToken;
|
| - }
|
| - return _bound.endToken;
|
| - }
|
| -
|
| - @override
|
| - Token get firstTokenAfterCommentAndMetadata => _name.beginToken;
|
| -
|
| - /**
|
| - * Return the token representing the 'extends' keyword, or `null` if there is
|
| - * no explicit upper bound.
|
| - */
|
| - @deprecated // Use "this.extendsKeyword"
|
| - Token get keyword => extendsKeyword;
|
| -
|
| - /**
|
| - * Set the token representing the 'extends' keyword to the given [token].
|
| - */
|
| - @deprecated // Use "this.extendsKeyword"
|
| - set keyword(Token token) {
|
| - extendsKeyword = token;
|
| - }
|
| -
|
| - /**
|
| - * Return the name of the type parameter.
|
| - */
|
| - SimpleIdentifier get name => _name;
|
| -
|
| - /**
|
| - * Set the name of the type parameter to the given [identifier].
|
| - */
|
| - void set name(SimpleIdentifier identifier) {
|
| - _name = _becomeParentOf(identifier);
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitTypeParameter(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - super.visitChildren(visitor);
|
| - _safelyVisitChild(_name, visitor);
|
| - _safelyVisitChild(_bound, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * Type parameters within a declaration.
|
| - *
|
| - * > typeParameterList ::=
|
| - * > '<' [TypeParameter] (',' [TypeParameter])* '>'
|
| - */
|
| -class TypeParameterList extends AstNode {
|
| - /**
|
| - * The left angle bracket.
|
| - */
|
| - final Token leftBracket;
|
| -
|
| - /**
|
| - * The type parameters in the list.
|
| - */
|
| - NodeList<TypeParameter> _typeParameters;
|
| -
|
| - /**
|
| - * The right angle bracket.
|
| - */
|
| - final Token rightBracket;
|
| -
|
| - /**
|
| - * Initialize a newly created list of type parameters.
|
| - */
|
| - TypeParameterList(
|
| - this.leftBracket, List<TypeParameter> typeParameters, this.rightBracket) {
|
| - _typeParameters = new NodeList<TypeParameter>(this, typeParameters);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => leftBracket;
|
| -
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()
|
| - ..add(leftBracket)
|
| - ..addAll(_typeParameters)
|
| - ..add(rightBracket);
|
| -
|
| - @override
|
| - Token get endToken => rightBracket;
|
| -
|
| - /**
|
| - * Return the type parameters for the type.
|
| - */
|
| - NodeList<TypeParameter> get typeParameters => _typeParameters;
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitTypeParameterList(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _typeParameters.accept(visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * An AST visitor that will recursively visit all of the nodes in an AST
|
| - * structure (like instances of the class [RecursiveAstVisitor]). In addition,
|
| - * every node will also be visited by using a single unified [visitNode] method.
|
| - *
|
| - * Subclasses that override a visit method must either invoke the overridden
|
| - * visit method or explicitly invoke the more general [visitNode] method.
|
| - * Failure to do so will cause the children of the visited node to not be
|
| - * visited.
|
| - */
|
| -class UnifyingAstVisitor<R> implements AstVisitor<R> {
|
| - @override
|
| - R visitAdjacentStrings(AdjacentStrings node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitAnnotation(Annotation node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitArgumentList(ArgumentList node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitAsExpression(AsExpression node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitAssertStatement(AssertStatement node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitAssignmentExpression(AssignmentExpression node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitAwaitExpression(AwaitExpression node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitBinaryExpression(BinaryExpression node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitBlock(Block node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitBlockFunctionBody(BlockFunctionBody node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitBooleanLiteral(BooleanLiteral node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitBreakStatement(BreakStatement node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitCascadeExpression(CascadeExpression node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitCatchClause(CatchClause node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitClassDeclaration(ClassDeclaration node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitClassTypeAlias(ClassTypeAlias node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitComment(Comment node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitCommentReference(CommentReference node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitCompilationUnit(CompilationUnit node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitConditionalExpression(ConditionalExpression node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitConstructorDeclaration(ConstructorDeclaration node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitConstructorFieldInitializer(ConstructorFieldInitializer node) =>
|
| - visitNode(node);
|
| -
|
| - @override
|
| - R visitConstructorName(ConstructorName node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitContinueStatement(ContinueStatement node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitDeclaredIdentifier(DeclaredIdentifier node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitDefaultFormalParameter(DefaultFormalParameter node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitDoStatement(DoStatement node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitDoubleLiteral(DoubleLiteral node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitEmptyFunctionBody(EmptyFunctionBody node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitEmptyStatement(EmptyStatement node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitEnumConstantDeclaration(EnumConstantDeclaration node) =>
|
| - visitNode(node);
|
| -
|
| - @override
|
| - R visitEnumDeclaration(EnumDeclaration node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitExportDirective(ExportDirective node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitExpressionFunctionBody(ExpressionFunctionBody node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitExpressionStatement(ExpressionStatement node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitExtendsClause(ExtendsClause node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitFieldDeclaration(FieldDeclaration node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitFieldFormalParameter(FieldFormalParameter node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitForEachStatement(ForEachStatement node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitFormalParameterList(FormalParameterList node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitForStatement(ForStatement node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitFunctionDeclaration(FunctionDeclaration node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitFunctionDeclarationStatement(FunctionDeclarationStatement node) =>
|
| - visitNode(node);
|
| -
|
| - @override
|
| - R visitFunctionExpression(FunctionExpression node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitFunctionExpressionInvocation(FunctionExpressionInvocation node) =>
|
| - visitNode(node);
|
| -
|
| - @override
|
| - R visitFunctionTypeAlias(FunctionTypeAlias node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) =>
|
| - visitNode(node);
|
| -
|
| - @override
|
| - R visitHideCombinator(HideCombinator node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitIfStatement(IfStatement node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitImplementsClause(ImplementsClause node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitImportDirective(ImportDirective node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitIndexExpression(IndexExpression node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitInstanceCreationExpression(InstanceCreationExpression node) =>
|
| - visitNode(node);
|
| -
|
| - @override
|
| - R visitIntegerLiteral(IntegerLiteral node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitInterpolationExpression(InterpolationExpression node) =>
|
| - visitNode(node);
|
| -
|
| - @override
|
| - R visitInterpolationString(InterpolationString node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitIsExpression(IsExpression node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitLabel(Label node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitLabeledStatement(LabeledStatement node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitLibraryDirective(LibraryDirective node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitLibraryIdentifier(LibraryIdentifier node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitListLiteral(ListLiteral node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitMapLiteral(MapLiteral node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitMapLiteralEntry(MapLiteralEntry node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitMethodDeclaration(MethodDeclaration node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitMethodInvocation(MethodInvocation node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitNamedExpression(NamedExpression node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitNativeClause(NativeClause node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitNativeFunctionBody(NativeFunctionBody node) => visitNode(node);
|
| -
|
| - R visitNode(AstNode node) {
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - R visitNullLiteral(NullLiteral node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitParenthesizedExpression(ParenthesizedExpression node) =>
|
| - visitNode(node);
|
| -
|
| - @override
|
| - R visitPartDirective(PartDirective node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitPartOfDirective(PartOfDirective node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitPostfixExpression(PostfixExpression node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitPrefixedIdentifier(PrefixedIdentifier node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitPrefixExpression(PrefixExpression node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitPropertyAccess(PropertyAccess node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitRedirectingConstructorInvocation(
|
| - RedirectingConstructorInvocation node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitRethrowExpression(RethrowExpression node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitReturnStatement(ReturnStatement node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitScriptTag(ScriptTag scriptTag) => visitNode(scriptTag);
|
| -
|
| - @override
|
| - R visitShowCombinator(ShowCombinator node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitSimpleFormalParameter(SimpleFormalParameter node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitSimpleIdentifier(SimpleIdentifier node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitSimpleStringLiteral(SimpleStringLiteral node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitStringInterpolation(StringInterpolation node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitSuperConstructorInvocation(SuperConstructorInvocation node) =>
|
| - visitNode(node);
|
| -
|
| - @override
|
| - R visitSuperExpression(SuperExpression node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitSwitchCase(SwitchCase node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitSwitchDefault(SwitchDefault node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitSwitchStatement(SwitchStatement node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitSymbolLiteral(SymbolLiteral node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitThisExpression(ThisExpression node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitThrowExpression(ThrowExpression node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) =>
|
| - visitNode(node);
|
| -
|
| - @override
|
| - R visitTryStatement(TryStatement node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitTypeArgumentList(TypeArgumentList node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitTypeName(TypeName node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitTypeParameter(TypeParameter node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitTypeParameterList(TypeParameterList node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitVariableDeclaration(VariableDeclaration node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitVariableDeclarationList(VariableDeclarationList node) =>
|
| - visitNode(node);
|
| -
|
| - @override
|
| - R visitVariableDeclarationStatement(VariableDeclarationStatement node) =>
|
| - visitNode(node);
|
| -
|
| - @override
|
| - R visitWhileStatement(WhileStatement node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitWithClause(WithClause node) => visitNode(node);
|
| -
|
| - @override
|
| - R visitYieldStatement(YieldStatement node) => visitNode(node);
|
| -}
|
| -
|
| -/**
|
| - * A directive that references a URI.
|
| - *
|
| - * > uriBasedDirective ::=
|
| - * > [ExportDirective]
|
| - * > | [ImportDirective]
|
| - * > | [PartDirective]
|
| - */
|
| -abstract class UriBasedDirective extends Directive {
|
| - /**
|
| - * The prefix of a URI using the `dart-ext` scheme to reference a native code
|
| - * library.
|
| - */
|
| - static String _DART_EXT_SCHEME = "dart-ext:";
|
| -
|
| - /**
|
| - * The URI referenced by this directive.
|
| - */
|
| - StringLiteral _uri;
|
| -
|
| - /**
|
| - * The content of the URI.
|
| - */
|
| - String uriContent;
|
| -
|
| - /**
|
| - * The source to which the URI was resolved.
|
| - */
|
| - Source source;
|
| -
|
| - /**
|
| - * Initialize a newly create URI-based directive. Either or both of the
|
| - * [comment] and [metadata] can be `null` if the directive does not have the
|
| - * corresponding attribute.
|
| - */
|
| - UriBasedDirective(
|
| - Comment comment, List<Annotation> metadata, StringLiteral uri)
|
| - : super(comment, metadata) {
|
| - _uri = _becomeParentOf(uri);
|
| - }
|
| -
|
| - /**
|
| - * Return the URI referenced by this directive.
|
| - */
|
| - StringLiteral get uri => _uri;
|
| -
|
| - /**
|
| - * Set the URI referenced by this directive to the given [uri].
|
| - */
|
| - void set uri(StringLiteral uri) {
|
| - _uri = _becomeParentOf(uri);
|
| - }
|
| -
|
| - /**
|
| - * Return the element associated with the URI of this directive, or `null` if
|
| - * the AST structure has not been resolved or if the URI could not be
|
| - * resolved. Examples of the latter case include a directive that contains an
|
| - * invalid URL or a URL that does not exist.
|
| - */
|
| - Element get uriElement;
|
| -
|
| - /**
|
| - * Validate this directive, but do not check for existence. Return a code
|
| - * indicating the problem if there is one, or `null` no problem
|
| - */
|
| - UriValidationCode validate() {
|
| - StringLiteral uriLiteral = uri;
|
| - if (uriLiteral is StringInterpolation) {
|
| - return UriValidationCode.URI_WITH_INTERPOLATION;
|
| - }
|
| - String uriContent = this.uriContent;
|
| - if (uriContent == null) {
|
| - return UriValidationCode.INVALID_URI;
|
| - }
|
| - if (this is ImportDirective && uriContent.startsWith(_DART_EXT_SCHEME)) {
|
| - return UriValidationCode.URI_WITH_DART_EXT_SCHEME;
|
| - }
|
| - try {
|
| - parseUriWithException(Uri.encodeFull(uriContent));
|
| - } on URISyntaxException {
|
| - return UriValidationCode.INVALID_URI;
|
| - }
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - super.visitChildren(visitor);
|
| - _safelyVisitChild(_uri, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * Validation codes returned by [UriBasedDirective.validate].
|
| - */
|
| -class UriValidationCode {
|
| - static const UriValidationCode INVALID_URI =
|
| - const UriValidationCode('INVALID_URI');
|
| -
|
| - static const UriValidationCode URI_WITH_INTERPOLATION =
|
| - const UriValidationCode('URI_WITH_INTERPOLATION');
|
| -
|
| - static const UriValidationCode URI_WITH_DART_EXT_SCHEME =
|
| - const UriValidationCode('URI_WITH_DART_EXT_SCHEME');
|
| -
|
| - /**
|
| - * The name of the validation code.
|
| - */
|
| - final String name;
|
| -
|
| - /**
|
| - * Initialize a newly created validation code to have the given [name].
|
| - */
|
| - const UriValidationCode(this.name);
|
| -
|
| - @override
|
| - String toString() => name;
|
| -}
|
| -
|
| -/**
|
| - * An identifier that has an initial value associated with it. Instances of this
|
| - * class are always children of the class [VariableDeclarationList].
|
| - *
|
| - * > variableDeclaration ::=
|
| - * > [SimpleIdentifier] ('=' [Expression])?
|
| - *
|
| - * TODO(paulberry): the grammar does not allow metadata to be associated with
|
| - * a VariableDeclaration, and currently we don't record comments for it either.
|
| - * Consider changing the class hierarchy so that [VariableDeclaration] does not
|
| - * extend [Declaration].
|
| - */
|
| -class VariableDeclaration extends Declaration {
|
| - /**
|
| - * The name of the variable being declared.
|
| - */
|
| - SimpleIdentifier _name;
|
| -
|
| - /**
|
| - * The equal sign separating the variable name from the initial value, or
|
| - * `null` if the initial value was not specified.
|
| - */
|
| - Token equals;
|
| -
|
| - /**
|
| - * The expression used to compute the initial value for the variable, or
|
| - * `null` if the initial value was not specified.
|
| - */
|
| - Expression _initializer;
|
| -
|
| - /**
|
| - * Initialize a newly created variable declaration. The [equals] and
|
| - * [initializer] can be `null` if there is no initializer.
|
| - */
|
| - VariableDeclaration(
|
| - SimpleIdentifier name, this.equals, Expression initializer)
|
| - : super(null, null) {
|
| - _name = _becomeParentOf(name);
|
| - _initializer = _becomeParentOf(initializer);
|
| - }
|
| -
|
| - @override
|
| - Iterable get childEntities =>
|
| - super._childEntities..add(_name)..add(equals)..add(_initializer);
|
| -
|
| - /**
|
| - * This overridden implementation of getDocumentationComment() looks in the
|
| - * grandparent node for dartdoc comments if no documentation is specifically
|
| - * available on the node.
|
| - */
|
| - @override
|
| - Comment get documentationComment {
|
| - Comment comment = super.documentationComment;
|
| - if (comment == null) {
|
| - if (parent != null && parent.parent != null) {
|
| - AstNode node = parent.parent;
|
| - if (node is AnnotatedNode) {
|
| - return node.documentationComment;
|
| - }
|
| - }
|
| - }
|
| - return comment;
|
| - }
|
| -
|
| - @override
|
| - VariableElement get element =>
|
| - _name != null ? (_name.staticElement as VariableElement) : null;
|
| -
|
| - @override
|
| - Token get endToken {
|
| - if (_initializer != null) {
|
| - return _initializer.endToken;
|
| - }
|
| - return _name.endToken;
|
| - }
|
| -
|
| - @override
|
| - Token get firstTokenAfterCommentAndMetadata => _name.beginToken;
|
| -
|
| - /**
|
| - * Return the expression used to compute the initial value for the variable,
|
| - * or `null` if the initial value was not specified.
|
| - */
|
| - Expression get initializer => _initializer;
|
| -
|
| - /**
|
| - * Set the expression used to compute the initial value for the variable to
|
| - * the given [expression].
|
| - */
|
| - void set initializer(Expression expression) {
|
| - _initializer = _becomeParentOf(expression);
|
| - }
|
| -
|
| - /**
|
| - * Return `true` if this variable was declared with the 'const' modifier.
|
| - */
|
| - bool get isConst {
|
| - AstNode parent = this.parent;
|
| - return parent is VariableDeclarationList && parent.isConst;
|
| - }
|
| -
|
| - /**
|
| - * Return `true` if this variable was declared with the 'final' modifier.
|
| - * Variables that are declared with the 'const' modifier will return `false`
|
| - * even though they are implicitly final.
|
| - */
|
| - bool get isFinal {
|
| - AstNode parent = this.parent;
|
| - return parent is VariableDeclarationList && parent.isFinal;
|
| - }
|
| -
|
| - /**
|
| - * Return the name of the variable being declared.
|
| - */
|
| - SimpleIdentifier get name => _name;
|
| -
|
| - /**
|
| - * Set the name of the variable being declared to the given [identifier].
|
| - */
|
| - void set name(SimpleIdentifier identifier) {
|
| - _name = _becomeParentOf(identifier);
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitVariableDeclaration(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - super.visitChildren(visitor);
|
| - _safelyVisitChild(_name, visitor);
|
| - _safelyVisitChild(_initializer, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * The declaration of one or more variables of the same type.
|
| - *
|
| - * > variableDeclarationList ::=
|
| - * > finalConstVarOrType [VariableDeclaration] (',' [VariableDeclaration])*
|
| - * >
|
| - * > finalConstVarOrType ::=
|
| - * > | 'final' [TypeName]?
|
| - * > | 'const' [TypeName]?
|
| - * > | 'var'
|
| - * > | [TypeName]
|
| - */
|
| -class VariableDeclarationList extends AnnotatedNode {
|
| - /**
|
| - * The token representing the 'final', 'const' or 'var' keyword, or `null` if
|
| - * no keyword was included.
|
| - */
|
| - Token keyword;
|
| -
|
| - /**
|
| - * The type of the variables being declared, or `null` if no type was provided.
|
| - */
|
| - TypeName _type;
|
| -
|
| - /**
|
| - * A list containing the individual variables being declared.
|
| - */
|
| - NodeList<VariableDeclaration> _variables;
|
| -
|
| - /**
|
| - * Initialize a newly created variable declaration list. Either or both of the
|
| - * [comment] and [metadata] can be `null` if the variable list does not have
|
| - * the corresponding attribute. The [keyword] can be `null` if a type was
|
| - * specified. The [type] must be `null` if the keyword is 'var'.
|
| - */
|
| - VariableDeclarationList(Comment comment, List<Annotation> metadata,
|
| - this.keyword, TypeName type, List<VariableDeclaration> variables)
|
| - : super(comment, metadata) {
|
| - _type = _becomeParentOf(type);
|
| - _variables = new NodeList<VariableDeclaration>(this, variables);
|
| - }
|
| -
|
| - /**
|
| - * TODO(paulberry): include commas.
|
| - */
|
| - @override
|
| - Iterable get childEntities => super._childEntities
|
| - ..add(keyword)
|
| - ..add(_type)
|
| - ..addAll(_variables);
|
| -
|
| - @override
|
| - Token get endToken => _variables.endToken;
|
| -
|
| - @override
|
| - Token get firstTokenAfterCommentAndMetadata {
|
| - if (keyword != null) {
|
| - return keyword;
|
| - } else if (_type != null) {
|
| - return _type.beginToken;
|
| - }
|
| - return _variables.beginToken;
|
| - }
|
| -
|
| - /**
|
| - * Return `true` if the variables in this list were declared with the 'const'
|
| - * modifier.
|
| - */
|
| - bool get isConst => keyword is KeywordToken &&
|
| - (keyword as KeywordToken).keyword == Keyword.CONST;
|
| -
|
| - /**
|
| - * Return `true` if the variables in this list were declared with the 'final'
|
| - * modifier. Variables that are declared with the 'const' modifier will return
|
| - * `false` even though they are implicitly final. (In other words, this is a
|
| - * syntactic check rather than a semantic check.)
|
| - */
|
| - bool get isFinal => keyword is KeywordToken &&
|
| - (keyword as KeywordToken).keyword == Keyword.FINAL;
|
| -
|
| - /**
|
| - * Return the type of the variables being declared, or `null` if no type was
|
| - * provided.
|
| - */
|
| - TypeName get type => _type;
|
| -
|
| - /**
|
| - * Set the type of the variables being declared to the given [typeName].
|
| - */
|
| - void set type(TypeName typeName) {
|
| - _type = _becomeParentOf(typeName);
|
| - }
|
| -
|
| - /**
|
| - * Return a list containing the individual variables being declared.
|
| - */
|
| - NodeList<VariableDeclaration> get variables => _variables;
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitVariableDeclarationList(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - super.visitChildren(visitor);
|
| - _safelyVisitChild(_type, visitor);
|
| - _variables.accept(visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A list of variables that are being declared in a context where a statement is
|
| - * required.
|
| - *
|
| - * > variableDeclarationStatement ::=
|
| - * > [VariableDeclarationList] ';'
|
| - */
|
| -class VariableDeclarationStatement extends Statement {
|
| - /**
|
| - * The variables being declared.
|
| - */
|
| - VariableDeclarationList _variableList;
|
| -
|
| - /**
|
| - * The semicolon terminating the statement.
|
| - */
|
| - Token semicolon;
|
| -
|
| - /**
|
| - * Initialize a newly created variable declaration statement.
|
| - */
|
| - VariableDeclarationStatement(
|
| - VariableDeclarationList variableList, this.semicolon) {
|
| - _variableList = _becomeParentOf(variableList);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => _variableList.beginToken;
|
| -
|
| - @override
|
| - Iterable get childEntities =>
|
| - new ChildEntities()..add(_variableList)..add(semicolon);
|
| -
|
| - @override
|
| - Token get endToken => semicolon;
|
| -
|
| - /**
|
| - * Return the variables being declared.
|
| - */
|
| - VariableDeclarationList get variables => _variableList;
|
| -
|
| - /**
|
| - * Set the variables being declared to the given list of [variables].
|
| - */
|
| - void set variables(VariableDeclarationList variables) {
|
| - _variableList = _becomeParentOf(variables);
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitVariableDeclarationStatement(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_variableList, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A while statement.
|
| - *
|
| - * > whileStatement ::=
|
| - * > 'while' '(' [Expression] ')' [Statement]
|
| - */
|
| -class WhileStatement extends Statement {
|
| - /**
|
| - * The token representing the 'while' keyword.
|
| - */
|
| - Token whileKeyword;
|
| -
|
| - /**
|
| - * The left parenthesis.
|
| - */
|
| - Token leftParenthesis;
|
| -
|
| - /**
|
| - * The expression used to determine whether to execute the body of the loop.
|
| - */
|
| - Expression _condition;
|
| -
|
| - /**
|
| - * The right parenthesis.
|
| - */
|
| - Token rightParenthesis;
|
| -
|
| - /**
|
| - * The body of the loop.
|
| - */
|
| - Statement _body;
|
| -
|
| - /**
|
| - * Initialize a newly created while statement.
|
| - */
|
| - WhileStatement(this.whileKeyword, this.leftParenthesis, Expression condition,
|
| - this.rightParenthesis, Statement body) {
|
| - _condition = _becomeParentOf(condition);
|
| - _body = _becomeParentOf(body);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => whileKeyword;
|
| -
|
| - /**
|
| - * Return the body of the loop.
|
| - */
|
| - Statement get body => _body;
|
| -
|
| - /**
|
| - * Set the body of the loop to the given [statement].
|
| - */
|
| - void set body(Statement statement) {
|
| - _body = _becomeParentOf(statement);
|
| - }
|
| -
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()
|
| - ..add(whileKeyword)
|
| - ..add(leftParenthesis)
|
| - ..add(_condition)
|
| - ..add(rightParenthesis)
|
| - ..add(_body);
|
| -
|
| - /**
|
| - * Return the expression used to determine whether to execute the body of the
|
| - * loop.
|
| - */
|
| - Expression get condition => _condition;
|
| -
|
| - /**
|
| - * Set the expression used to determine whether to execute the body of the
|
| - * loop to the given [expression].
|
| - */
|
| - void set condition(Expression expression) {
|
| - _condition = _becomeParentOf(expression);
|
| - }
|
| -
|
| - @override
|
| - Token get endToken => _body.endToken;
|
| -
|
| - /**
|
| - * Return the token representing the 'while' keyword.
|
| - */
|
| - @deprecated // Use "this.whileKeyword"
|
| - Token get keyword => whileKeyword;
|
| -
|
| - /**
|
| - * Set the token representing the 'while' keyword to the given [token].
|
| - */
|
| - @deprecated // Use "this.whileKeyword"
|
| - set keyword(Token token) {
|
| - whileKeyword = token;
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitWhileStatement(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_condition, visitor);
|
| - _safelyVisitChild(_body, visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * The with clause in a class declaration.
|
| - *
|
| - * > withClause ::=
|
| - * > 'with' [TypeName] (',' [TypeName])*
|
| - */
|
| -class WithClause extends AstNode {
|
| - /**
|
| - * The token representing the 'with' keyword.
|
| - */
|
| - Token withKeyword;
|
| -
|
| - /**
|
| - * The names of the mixins that were specified.
|
| - */
|
| - NodeList<TypeName> _mixinTypes;
|
| -
|
| - /**
|
| - * Initialize a newly created with clause.
|
| - */
|
| - WithClause(this.withKeyword, List<TypeName> mixinTypes) {
|
| - _mixinTypes = new NodeList<TypeName>(this, mixinTypes);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken => withKeyword;
|
| -
|
| - /**
|
| - * TODO(paulberry): add commas.
|
| - */
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()
|
| - ..add(withKeyword)
|
| - ..addAll(_mixinTypes);
|
| -
|
| - @override
|
| - Token get endToken => _mixinTypes.endToken;
|
| -
|
| - /**
|
| - * Set the token representing the 'with' keyword to the given [token].
|
| - */
|
| - @deprecated // Use "this.withKeyword"
|
| - void set mixinKeyword(Token token) {
|
| - this.withKeyword = token;
|
| - }
|
| -
|
| - /**
|
| - * Return the names of the mixins that were specified.
|
| - */
|
| - NodeList<TypeName> get mixinTypes => _mixinTypes;
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitWithClause(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _mixinTypes.accept(visitor);
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * A yield statement.
|
| - *
|
| - * > yieldStatement ::=
|
| - * > 'yield' '*'? [Expression] ‘;’
|
| - */
|
| -class YieldStatement extends Statement {
|
| - /**
|
| - * The 'yield' keyword.
|
| - */
|
| - Token yieldKeyword;
|
| -
|
| - /**
|
| - * The star optionally following the 'yield' keyword.
|
| - */
|
| - Token star;
|
| -
|
| - /**
|
| - * The expression whose value will be yielded.
|
| - */
|
| - Expression _expression;
|
| -
|
| - /**
|
| - * The semicolon following the expression.
|
| - */
|
| - Token semicolon;
|
| -
|
| - /**
|
| - * Initialize a newly created yield expression. The [star] can be `null` if no
|
| - * star was provided.
|
| - */
|
| - YieldStatement(
|
| - this.yieldKeyword, this.star, Expression expression, this.semicolon) {
|
| - _expression = _becomeParentOf(expression);
|
| - }
|
| -
|
| - @override
|
| - Token get beginToken {
|
| - if (yieldKeyword != null) {
|
| - return yieldKeyword;
|
| - }
|
| - return _expression.beginToken;
|
| - }
|
| -
|
| - @override
|
| - Iterable get childEntities => new ChildEntities()
|
| - ..add(yieldKeyword)
|
| - ..add(star)
|
| - ..add(_expression)
|
| - ..add(semicolon);
|
| -
|
| - @override
|
| - Token get endToken {
|
| - if (semicolon != null) {
|
| - return semicolon;
|
| - }
|
| - return _expression.endToken;
|
| - }
|
| -
|
| - /**
|
| - * Return the expression whose value will be yielded.
|
| - */
|
| - Expression get expression => _expression;
|
| -
|
| - /**
|
| - * Set the expression whose value will be yielded to the given [expression].
|
| - */
|
| - void set expression(Expression expression) {
|
| - _expression = _becomeParentOf(expression);
|
| - }
|
| -
|
| - @override
|
| - accept(AstVisitor visitor) => visitor.visitYieldStatement(this);
|
| -
|
| - @override
|
| - void visitChildren(AstVisitor visitor) {
|
| - _safelyVisitChild(_expression, visitor);
|
| - }
|
| -}
|
|
|
Chromium Code Reviews
Issue 1400473008:
Roll Observatory packages and add a roll script (Closed)
Base URL: git@github.com:dart-lang/observatory_pub_packages.git@master