Index: pkg/analyzer/lib/src/summary/fasta/expressions.dart |
diff --git a/pkg/analyzer/lib/src/summary/fasta/expressions.dart b/pkg/analyzer/lib/src/summary/fasta/expressions.dart |
deleted file mode 100644 |
index 87c79ab3bf9ecb59c03e22e110b08c93ac1efb18..0000000000000000000000000000000000000000 |
--- a/pkg/analyzer/lib/src/summary/fasta/expressions.dart |
+++ /dev/null |
@@ -1,308 +0,0 @@ |
-// Copyright (c) 2017, 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. |
- |
-/// Minimal AST used to represent constant and initializer expressions. |
-/// |
-/// The AST definitions here are kept small by removing anything that we don't |
-/// need for the purpose of summarization: |
-/// |
-/// * A tree representing constants will not contain nodes that are not |
-/// allowed. If a parsed program contains a subexpression that is invalid, |
-/// we'll represent it with an `Invalid` node. |
-/// |
-/// * A tree representing initializers will only contain the subset of the |
-/// initializer expression that is needed to infer the type of the initialized |
-/// variable. For example, function closures, arguments to constructors, and |
-/// other similar bits are hidden using `Opaque` nodes. |
-library summary.src.expressions; |
- |
-// We reuse the scanner constants to represent all binary and unary operators. |
-import 'visitor.dart'; |
- |
-export 'visitor.dart'; |
- |
-/// A cast expression. |
-class As extends Expression { |
- final Expression exp; |
- final TypeRef type; |
- As(this.exp, this.type); |
- |
- bool get isAs => true; |
- accept(v) => v.visitAs(this); |
- toString() => '$exp as $type'; |
-} |
- |
-/// All binary expressions, including if-null. |
-class Binary extends Expression { |
- final Expression left; |
- final Expression right; |
- final int operator; |
- Binary(this.left, this.right, this.operator); |
- |
- bool get isBinary => true; |
- accept(v) => v.visitBinary(this); |
- toString() => '$left _ $right'; |
-} |
- |
-/// A literal like `false`. |
-class BoolLiteral extends Expression { |
- final bool value; |
- BoolLiteral(this.value); |
- |
- accept(v) => v.visitBool(this); |
- toString() => '$value'; |
-} |
- |
-/// Expressions like `a ? b : c`. |
-class Conditional extends Expression { |
- final Expression test; |
- final Expression trueBranch; |
- final Expression falseBranch; |
- Conditional(this.test, this.trueBranch, this.falseBranch); |
- |
- bool get isConditional => true; |
- accept(v) => v.visitConditional(this); |
- toString() => '$test ? $trueBranch : $falseBranch'; |
-} |
- |
-/// A `const Foo()` creation. |
-class ConstCreation extends Expression { |
- final ConstructorName constructor; |
- |
- /// Passed arguments, which can be expressions (if the argument is positional) |
- /// or a [NamedArg]. |
- final List<Expression> positionalArgs; |
- final List<NamedArg> namedArgs; |
- ConstCreation(this.constructor, this.positionalArgs, this.namedArgs); |
- |
- accept(v) => v.visitConstCreation(this); |
-} |
- |
-/// The type and possibly name of a constructor. |
-class ConstructorName { |
- final TypeRef type; |
- final String name; |
- ConstructorName(this.type, this.name); |
- |
- toString() => "ctor: $type.$name"; |
-} |
- |
-/// A literal like `1.2`. |
-class DoubleLiteral extends Expression { |
- final double value; |
- DoubleLiteral(this.value); |
- |
- accept(v) => v.visitDouble(this); |
- toString() => '$value'; |
-} |
- |
-/// Root of all expressions |
-abstract class Expression { |
- bool get isAs => false; |
- bool get isBinary => false; |
- bool get isConditional => false; |
- bool get isIdentical => false; |
- bool get isIs => false; |
- bool get isLoad => false; |
- bool get isOpaqueOp => false; |
- bool get isRef => false; |
- bool get isUnary => false; |
- |
- accept(Visitor v); |
-} |
- |
-/// An identical expression: `identical(a, b)`. |
-// TODO(sigmund): consider merging it into binary? |
-class Identical extends Expression { |
- final Expression left; |
- final Expression right; |
- Identical(this.left, this.right); |
- |
- bool get isIdentical => true; |
- accept(v) => v.visitIdentical(this); |
- toString() => 'identical($left, $right)'; |
-} |
- |
-/// A literal like `1`. |
-class IntLiteral extends Expression { |
- final int value; |
- IntLiteral(this.value); |
- |
- accept(v) => v.visitInt(this); |
- toString() => '$value'; |
-} |
- |
-/// An erroneous expression, typically encapsulates code that is not expected |
-/// in a constant context. |
-class Invalid extends Expression { |
- String hint; |
- Invalid({this.hint}); |
- accept(v) => v.visitInvalid(this); |
- |
- toString() => '(err: $hint)'; |
-} |
- |
-/// An instance check expression. |
-class Is extends Expression { |
- final Expression exp; |
- final TypeRef type; |
- Is(this.exp, this.type); |
- |
- bool get isIs => true; |
- accept(v) => v.visitIs(this); |
- toString() => '$exp is $type'; |
-} |
- |
-/// An entry in a map literal. |
-class KeyValuePair { |
- final Expression key; |
- final Expression value; |
- KeyValuePair(this.key, this.value); |
- |
- toString() => '(p: $key, $value)'; |
-} |
- |
-/// A list literal like: `[1, 2]`. |
-class ListLiteral extends Expression { |
- final TypeRef elementType; |
- final List<Expression> values; |
- final bool isConst; |
- ListLiteral(this.elementType, this.values, this.isConst); |
- |
- accept(v) => v.visitList(this); |
- toString() => '(list<$elementType>$values)'; |
-} |
- |
-/// A property extraction expression, such as: `(e).foo` |
-// TODO(sigmund): consider merging it into binary? |
-class Load extends Expression { |
- final Expression left; |
- final String name; |
- Load(this.left, this.name); |
- |
- bool get isLoad => true; |
- accept(v) => v.visitLoad(this); |
- toString() => '$left.$name'; |
-} |
- |
-/// A map literal like: `{'a': 2}`. |
-class MapLiteral extends Expression { |
- final List<TypeRef> types; |
- final List<KeyValuePair> values; |
- final bool isConst; |
- |
- MapLiteral(this.types, this.values, this.isConst) { |
- assert(types.length <= 2); |
- } |
- |
- accept(v) => v.visitMap(this); |
- toString() => '(map<${types.map((t) => "$t").join(", ")}>: $values)'; |
-} |
- |
-/// Representation for a named argument. |
-class NamedArg { |
- final String name; |
- final Expression value; |
- NamedArg(this.name, this.value); |
-} |
- |
-/// The `null` literal. |
-class NullLiteral extends Expression { |
- NullLiteral(); |
- |
- accept(v) => v.visitNull(this); |
- toString() => 'null'; |
-} |
- |
-/// An opaque expression with possibly a known type. |
-class Opaque extends Expression { |
- final TypeRef type; |
- final String hint; |
- |
- Opaque({this.type, this.hint}); |
- |
- accept(v) => v.visitOpaque(this); |
- |
- toString() { |
- var sb = new StringBuffer(); |
- sb.write('(o:'); |
- if (hint != null) sb.write(' $hint'); |
- if (type != null) sb.write(' $type'); |
- return '$sb)'; |
- } |
-} |
- |
-/// Marker that some part of the AST was abstracted away. |
-/// |
-/// This node does not provide additional information, other than indicating |
-/// that the AST does not include the full initializer. For example, |
-/// this is in assignments, pre and postfix operators, and cascades to indicate |
-/// that we ignored part of those complex expressions. |
-class OpaqueOp extends Expression { |
- final Expression exp; |
- final String hint; |
- OpaqueOp(this.exp, {this.hint}); |
- |
- bool get isOpaqueOp => true; |
- accept(v) => v.visitOpaqueOp(this); |
-} |
- |
-/// A name reference. |
-class Ref extends Expression { |
- final String name; |
- final Ref prefix; |
- |
- Ref(this.name, [this.prefix]) { |
- assert(prefixDepth <= 2); |
- } |
- |
- bool get isRef => true; |
- |
- int get prefixDepth => prefix == null ? 0 : prefix.prefixDepth; |
- accept(v) => v.visitRef(this); |
- toString() => 'r:${prefix == null ? "" : "$prefix."}$name'; |
-} |
- |
-/// A literal like `"foo"`. |
-class StringLiteral extends Expression { |
- final String value; |
- StringLiteral(this.value); |
- |
- accept(v) => v.visitString(this); |
- toString() => '$value'; |
-} |
- |
-/// A literal like `#foo.bar`. |
-class SymbolLiteral extends Expression { |
- final String value; |
- SymbolLiteral(this.value); |
- |
- accept(v) => v.visitSymbol(this); |
- toString() => '#$value'; |
-} |
- |
-/// A reference to a type (used for opaque nodes, is checks, and as checks). |
-/// |
-/// Note that types are not nodes in the expression tree. |
-class TypeRef { |
- final Ref name; |
- final List<TypeRef> typeArguments; |
- TypeRef(this.name, this.typeArguments); |
- |
- toString() { |
- var args = typeArguments == null ? "" : "<${typeArguments.join(', ')}>"; |
- return 't:$name$args'; |
- } |
-} |
- |
-/// All unary expressions, such as `-1` or `!b` |
-class Unary extends Expression { |
- final Expression exp; |
- final int operator; |
- Unary(this.exp, this.operator); |
- |
- bool get isUnary => true; |
- accept(v) => v.visitUnary(this); |
- toString() => '_ $exp'; |
-} |