mirror of
https://github.com/dart-lang/sdk
synced 2024-09-20 01:28:21 +00:00
Remove type parameters from the Fasta BodyBuilder
We are pivoting our implementation of FE/Analyzer integration a little bit, and so the BodyBuilder will not be parameterized in exactly the same way. Remove the existing parameterization from it and all the supporting classes. This requires specializing the BodyBuilder to the front end's instantiation of it and deleting the corresponding code in the Analyzer. Fixes https://github.com/dart-lang/sdk/issues/33503 Change-Id: I3ddcd2c5f5ebd8f2ff95f2ec8d4c7b98b70a0b0a Reviewed-on: https://dart-review.googlesource.com/61502 Commit-Queue: Kevin Millikin <kmillikin@google.com> Reviewed-by: Dmitry Stefantsov <dmitryas@google.com> Reviewed-by: Paul Berry <paulberry@google.com> Reviewed-by: Dan Rubel <danrubel@google.com>
This commit is contained in:
Kevin Millikin
commit-bot@chromium.org
parent
74dd5440f1
commit
f2eaf6aae7
|
|
@ -1,580 +0,0 @@
|
|||
// Copyright (c) 2018, 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.
|
||||
|
||||
import 'package:analyzer/dart/ast/ast.dart';
|
||||
import 'package:analyzer/dart/ast/ast_factory.dart';
|
||||
import 'package:analyzer/src/fasta/ast_building_factory.dart';
|
||||
import 'package:front_end/src/fasta/kernel/expression_generator.dart' as fasta;
|
||||
import 'package:front_end/src/fasta/kernel/expression_generator_helper.dart';
|
||||
import 'package:front_end/src/fasta/kernel/forest.dart' as fasta;
|
||||
import 'package:front_end/src/scanner/token.dart';
|
||||
import 'package:kernel/ast.dart' as kernel
|
||||
show DartType, Initializer, Member, Name, Procedure;
|
||||
|
||||
class AnalyzerDeferredAccessGenerator extends AnalyzerExpressionGenerator
|
||||
with fasta.DeferredAccessGenerator<Expression, Statement, Arguments> {
|
||||
final Token token;
|
||||
final fasta.PrefixBuilder builder;
|
||||
final fasta.Generator<Expression, Statement, Arguments> generator;
|
||||
|
||||
AnalyzerDeferredAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
AstFactory astFactory,
|
||||
this.token,
|
||||
this.builder,
|
||||
this.generator)
|
||||
: super(helper, astFactory);
|
||||
|
||||
@override
|
||||
Expression buildSimpleRead() => generator.buildSimpleRead();
|
||||
}
|
||||
|
||||
class AnalyzerDelayedAssignmentGenerator extends AnalyzerExpressionGenerator
|
||||
with fasta.DelayedAssignment<Expression, Statement, Arguments> {
|
||||
final Token token;
|
||||
final fasta.Generator<Expression, Statement, Arguments> generator;
|
||||
final String assignmentOperator;
|
||||
final Expression value;
|
||||
|
||||
AnalyzerDelayedAssignmentGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
AstFactory astFactory,
|
||||
this.token,
|
||||
this.generator,
|
||||
this.assignmentOperator,
|
||||
this.value)
|
||||
: super(helper, astFactory);
|
||||
|
||||
@override
|
||||
Expression buildSimpleRead() => astFactory.assignmentExpression(
|
||||
generator.buildSimpleRead(), token, value);
|
||||
|
||||
@override
|
||||
Expression doInvocation(int offset, Arguments arguments) => buildSimpleRead();
|
||||
}
|
||||
|
||||
class AnalyzerDelayedPostfixIncrementGenerator
|
||||
extends AnalyzerExpressionGenerator
|
||||
with fasta.DelayedPostfixIncrement<Expression, Statement, Arguments> {
|
||||
final Token token;
|
||||
final fasta.Generator<Expression, Statement, Arguments> generator;
|
||||
final kernel.Name binaryOperator;
|
||||
final kernel.Procedure interfaceTarget;
|
||||
|
||||
AnalyzerDelayedPostfixIncrementGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
AstFactory astFactory,
|
||||
this.token,
|
||||
this.generator,
|
||||
this.binaryOperator,
|
||||
this.interfaceTarget)
|
||||
: super(helper, astFactory);
|
||||
|
||||
@override
|
||||
Expression buildSimpleRead() =>
|
||||
astFactory.postfixExpression(generator.buildSimpleRead(), token);
|
||||
|
||||
@override
|
||||
Expression doInvocation(int offset, Arguments arguments) => buildSimpleRead();
|
||||
}
|
||||
|
||||
abstract class AnalyzerExpressionGenerator
|
||||
implements fasta.Generator<Expression, Statement, Arguments> {
|
||||
final ExpressionGeneratorHelper<Expression, Statement, Arguments> helper;
|
||||
|
||||
final AstFactory astFactory;
|
||||
|
||||
AnalyzerExpressionGenerator(this.helper, this.astFactory);
|
||||
|
||||
fasta.Forest<Expression, Statement, Token, Arguments> get forest =>
|
||||
helper.forest;
|
||||
|
||||
@override
|
||||
// TODO: implement isInitializer
|
||||
bool get isInitializer => throw new UnimplementedError();
|
||||
|
||||
@override
|
||||
// TODO: implement isThisPropertyAccess
|
||||
bool get isThisPropertyAccess => throw new UnimplementedError();
|
||||
|
||||
@override
|
||||
// TODO: implement plainNameForRead
|
||||
String get plainNameForRead => throw new UnimplementedError();
|
||||
|
||||
@override
|
||||
// TODO: implement plainNameForWrite
|
||||
String get plainNameForWrite => throw new UnimplementedError();
|
||||
|
||||
@override
|
||||
// TODO: implement uri
|
||||
Uri get uri => throw new UnimplementedError();
|
||||
|
||||
@override
|
||||
Expression buildAssignment(Expression value, {bool voidContext}) {
|
||||
// TODO(brianwilkerson) Figure out how to get the token for the operator.
|
||||
return astFactory.assignmentExpression(buildSimpleRead(), null, value);
|
||||
}
|
||||
|
||||
@override
|
||||
Expression buildCompoundAssignment(
|
||||
kernel.Name binaryOperator, Expression value,
|
||||
{int offset,
|
||||
bool voidContext,
|
||||
kernel.Procedure interfaceTarget,
|
||||
bool isPreIncDec}) {
|
||||
// TODO(brianwilkerson) Figure out how to get the token for the operator.
|
||||
return astFactory.assignmentExpression(buildSimpleRead(), null, value);
|
||||
}
|
||||
|
||||
@override
|
||||
kernel.Initializer buildFieldInitializer(Map<String, int> initializedFields) {
|
||||
// TODO: implement buildFieldInitializer
|
||||
throw new UnimplementedError();
|
||||
}
|
||||
|
||||
/// For most accessors, the AST structure will be the same whether the result
|
||||
/// is being used for access or modification.
|
||||
Expression buildForEffect() => buildSimpleRead();
|
||||
|
||||
@override
|
||||
Expression buildNullAwareAssignment(
|
||||
Expression value, kernel.DartType type, int offset,
|
||||
{bool voidContext}) {
|
||||
// TODO(brianwilkerson) Figure out how to get the token for the operator.
|
||||
// TODO(brianwilkerson) Capture the type information?
|
||||
return astFactory.assignmentExpression(buildSimpleRead(), null, value);
|
||||
}
|
||||
|
||||
@override
|
||||
Expression buildPostfixIncrement(kernel.Name binaryOperator,
|
||||
{int offset, bool voidContext, kernel.Procedure interfaceTarget}) {
|
||||
// TODO(brianwilkerson) Figure out how to get the token for the operator.
|
||||
return astFactory.postfixExpression(buildSimpleRead(), null);
|
||||
}
|
||||
|
||||
@override
|
||||
Expression buildPrefixIncrement(kernel.Name binaryOperator,
|
||||
{int offset, bool voidContext, kernel.Procedure interfaceTarget}) {
|
||||
// TODO(brianwilkerson) Figure out how to get the token for the operator.
|
||||
return astFactory.prefixExpression(null, buildSimpleRead());
|
||||
}
|
||||
|
||||
@override
|
||||
buildPropertyAccess(fasta.IncompleteSendGenerator send, int operatorOffset,
|
||||
bool isNullAware) {
|
||||
// TODO: implement buildPropertyAccess
|
||||
// return astFactory.propertyAccess(buildSimpleRead(), null, null);
|
||||
throw new UnimplementedError();
|
||||
}
|
||||
|
||||
@override
|
||||
buildThrowNoSuchMethodError(Expression receiver, Arguments arguments,
|
||||
{bool isSuper,
|
||||
bool isGetter,
|
||||
bool isSetter,
|
||||
bool isStatic,
|
||||
String name,
|
||||
int offset,
|
||||
/*LocatedMessage*/ argMessage}) {
|
||||
// TODO: implement buildThrowNoSuchMethodError
|
||||
throw new UnimplementedError();
|
||||
}
|
||||
|
||||
@override
|
||||
kernel.DartType buildTypeWithBuiltArguments(List<kernel.DartType> arguments,
|
||||
{bool nonInstanceAccessIsError: false}) {
|
||||
// TODO: implement buildTypeWithBuiltArguments
|
||||
throw new UnimplementedError();
|
||||
}
|
||||
|
||||
@override
|
||||
doInvocation(int offset, Arguments arguments) {
|
||||
// TODO: implement doInvocation
|
||||
throw new UnimplementedError();
|
||||
}
|
||||
|
||||
@override
|
||||
Expression makeInvalidRead() {
|
||||
// TODO: implement makeInvalidRead
|
||||
throw new UnimplementedError();
|
||||
}
|
||||
|
||||
@override
|
||||
Expression makeInvalidWrite(Expression value) {
|
||||
// TODO: implement makeInvalidWrite
|
||||
throw new UnimplementedError();
|
||||
}
|
||||
|
||||
@override
|
||||
void printOn(StringSink sink) {
|
||||
// TODO: implement printOn
|
||||
throw new UnimplementedError();
|
||||
}
|
||||
|
||||
@override
|
||||
T storeOffset<T>(T node, int offset) {
|
||||
// TODO: implement storeOffset
|
||||
throw new UnimplementedError();
|
||||
}
|
||||
}
|
||||
|
||||
class AnalyzerIndexedAccessGenerator extends AnalyzerExpressionGenerator
|
||||
with fasta.IndexedAccessGenerator<Expression, Statement, Arguments> {
|
||||
/// The expression computing the object on which the index operation will be
|
||||
/// invoked.
|
||||
final Expression target;
|
||||
|
||||
/// The left bracket.
|
||||
final Token leftBracket;
|
||||
|
||||
/// The expression computing the argument for the index operation.
|
||||
final Expression index;
|
||||
|
||||
/// The right bracket.
|
||||
final Token rightBracket;
|
||||
|
||||
/// Initialize a newly created generator to have the given helper.
|
||||
AnalyzerIndexedAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
AstFactory astFactory,
|
||||
this.target,
|
||||
this.leftBracket,
|
||||
this.index,
|
||||
this.rightBracket)
|
||||
: super(helper, astFactory);
|
||||
|
||||
@override
|
||||
Token get token => leftBracket;
|
||||
|
||||
@override
|
||||
Expression buildSimpleRead() => astFactory.indexExpressionForTarget(
|
||||
target, leftBracket, index, rightBracket);
|
||||
}
|
||||
|
||||
class AnalyzerLargeIntAccessGenerator extends AnalyzerExpressionGenerator
|
||||
with fasta.LargeIntAccessGenerator<Expression, Statement, Arguments> {
|
||||
final Token token;
|
||||
|
||||
AnalyzerLargeIntAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
AstFactory astFactory,
|
||||
this.token)
|
||||
: super(helper, astFactory);
|
||||
|
||||
@override
|
||||
Expression buildSimpleRead() => astFactory.integerLiteral(token, null);
|
||||
}
|
||||
|
||||
class AnalyzerLoadLibraryGenerator extends AnalyzerExpressionGenerator
|
||||
with fasta.LoadLibraryGenerator<Expression, Statement, Arguments> {
|
||||
final Token token;
|
||||
final fasta.LoadLibraryBuilder builder;
|
||||
|
||||
AnalyzerLoadLibraryGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
AstFactory astFactory,
|
||||
this.token,
|
||||
this.builder)
|
||||
: super(helper, astFactory);
|
||||
|
||||
@override
|
||||
Expression buildSimpleRead() {
|
||||
// TODO: implement buildSimpleRead
|
||||
throw new UnimplementedError();
|
||||
}
|
||||
}
|
||||
|
||||
class AnalyzerNullAwarePropertyAccessGenerator
|
||||
extends AnalyzerExpressionGenerator
|
||||
with
|
||||
fasta.NullAwarePropertyAccessGenerator<Expression, Statement,
|
||||
Arguments> {
|
||||
final Expression target;
|
||||
final Token operator;
|
||||
final SimpleIdentifier propertyName;
|
||||
|
||||
AnalyzerNullAwarePropertyAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
AstFactory astFactory,
|
||||
this.target,
|
||||
this.operator,
|
||||
this.propertyName)
|
||||
: super(helper, astFactory);
|
||||
|
||||
@override
|
||||
Token get token => operator;
|
||||
|
||||
@override
|
||||
Expression buildSimpleRead() =>
|
||||
astFactory.propertyAccess(target, operator, propertyName);
|
||||
}
|
||||
|
||||
class AnalyzerPropertyAccessGenerator extends AnalyzerExpressionGenerator
|
||||
with fasta.PropertyAccessGenerator<Expression, Statement, Arguments> {
|
||||
final Token token;
|
||||
final Expression receiver;
|
||||
final kernel.Name name;
|
||||
final kernel.Member getter;
|
||||
final kernel.Member setter;
|
||||
|
||||
AnalyzerPropertyAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
AstFactory astFactory,
|
||||
this.token,
|
||||
this.receiver,
|
||||
this.name,
|
||||
this.getter,
|
||||
this.setter)
|
||||
: super(helper, astFactory);
|
||||
|
||||
@override
|
||||
// TODO(brianwilkerson) Figure out how to get the property name token (or node).
|
||||
Expression buildSimpleRead() =>
|
||||
astFactory.propertyAccess(receiver, token, null);
|
||||
}
|
||||
|
||||
class AnalyzerReadOnlyAccessGenerator extends AnalyzerExpressionGenerator
|
||||
with fasta.ReadOnlyAccessGenerator<Expression, Statement, Arguments> {
|
||||
final Token token;
|
||||
final Expression expression;
|
||||
final String plainNameForRead;
|
||||
|
||||
AnalyzerReadOnlyAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
AstFactory astFactory,
|
||||
this.token,
|
||||
this.expression,
|
||||
this.plainNameForRead)
|
||||
: super(helper, astFactory);
|
||||
|
||||
@override
|
||||
Expression buildSimpleRead() {
|
||||
// TODO: implement buildSimpleRead
|
||||
throw new UnimplementedError();
|
||||
}
|
||||
}
|
||||
|
||||
class AnalyzerStaticAccessGenerator extends AnalyzerExpressionGenerator
|
||||
with fasta.StaticAccessGenerator<Expression, Statement, Arguments> {
|
||||
final Token token;
|
||||
final kernel.Member getter;
|
||||
final kernel.Member setter;
|
||||
|
||||
AnalyzerStaticAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
AstFactory astFactory,
|
||||
this.token,
|
||||
this.getter,
|
||||
this.setter)
|
||||
: super(helper, astFactory);
|
||||
|
||||
@override
|
||||
kernel.Member get readTarget {
|
||||
// TODO: implement readTarget
|
||||
throw new UnimplementedError();
|
||||
}
|
||||
|
||||
@override
|
||||
Expression buildSimpleRead() {
|
||||
// TODO: implement buildSimpleRead
|
||||
throw new UnimplementedError();
|
||||
}
|
||||
}
|
||||
|
||||
class AnalyzerSuperIndexedAccessGenerator extends AnalyzerExpressionGenerator
|
||||
with fasta.SuperIndexedAccessGenerator<Expression, Statement, Arguments> {
|
||||
/// The expression computing the object on which the index operation will be
|
||||
/// invoked.
|
||||
final Expression target;
|
||||
|
||||
/// The left bracket.
|
||||
final Token leftBracket;
|
||||
|
||||
/// The expression computing the argument for the index operation.
|
||||
final Expression index;
|
||||
|
||||
/// The right bracket.
|
||||
final Token rightBracket;
|
||||
|
||||
/// Initialize a newly created generator to have the given helper.
|
||||
AnalyzerSuperIndexedAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
AstFactory astFactory,
|
||||
this.target,
|
||||
this.leftBracket,
|
||||
this.index,
|
||||
this.rightBracket)
|
||||
: super(helper, astFactory);
|
||||
|
||||
@override
|
||||
Token get token => leftBracket;
|
||||
|
||||
@override
|
||||
Expression buildSimpleRead() => astFactory.indexExpressionForTarget(
|
||||
target, leftBracket, index, rightBracket);
|
||||
}
|
||||
|
||||
class AnalyzerSuperPropertyAccessGenerator extends AnalyzerExpressionGenerator
|
||||
with fasta.SuperPropertyAccessGenerator<Expression, Statement, Arguments> {
|
||||
/// The `super` keyword.
|
||||
Token superKeyword;
|
||||
|
||||
/// The `.` or `?.` operator.
|
||||
Token operator;
|
||||
|
||||
/// The name of the property being accessed,
|
||||
SimpleIdentifier propertyName;
|
||||
|
||||
AnalyzerSuperPropertyAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
AstFactory astFactory,
|
||||
this.superKeyword,
|
||||
this.operator,
|
||||
this.propertyName)
|
||||
: super(helper, astFactory);
|
||||
|
||||
@override
|
||||
Token get token => operator;
|
||||
|
||||
@override
|
||||
Expression buildSimpleRead() => astFactory.propertyAccess(
|
||||
astFactory.superExpression(superKeyword), operator, propertyName);
|
||||
}
|
||||
|
||||
class AnalyzerThisIndexedAccessGenerator extends AnalyzerExpressionGenerator
|
||||
with fasta.ThisIndexedAccessGenerator<Expression, Statement, Arguments> {
|
||||
/// The expression computing the object on which the index operation will be
|
||||
/// invoked.
|
||||
final Expression target;
|
||||
|
||||
/// The left bracket.
|
||||
final Token leftBracket;
|
||||
|
||||
/// The expression computing the argument for the index operation.
|
||||
final Expression index;
|
||||
|
||||
/// The right bracket.
|
||||
final Token rightBracket;
|
||||
|
||||
/// Initialize a newly created generator to have the given helper.
|
||||
AnalyzerThisIndexedAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
AstFactory astFactory,
|
||||
this.target,
|
||||
this.leftBracket,
|
||||
this.index,
|
||||
this.rightBracket)
|
||||
: super(helper, astFactory);
|
||||
|
||||
@override
|
||||
Token get token => leftBracket;
|
||||
|
||||
@override
|
||||
Expression buildSimpleRead() => astFactory.indexExpressionForTarget(
|
||||
target, leftBracket, index, rightBracket);
|
||||
}
|
||||
|
||||
class AnalyzerThisPropertyAccessGenerator extends AnalyzerExpressionGenerator
|
||||
with fasta.ThisPropertyAccessGenerator<Expression, Statement, Arguments> {
|
||||
final Token token;
|
||||
final kernel.Name name;
|
||||
final kernel.Member getter;
|
||||
final kernel.Member setter;
|
||||
|
||||
AnalyzerThisPropertyAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
AstFactory astFactory,
|
||||
this.token,
|
||||
this.name,
|
||||
this.getter,
|
||||
this.setter)
|
||||
: super(helper, astFactory);
|
||||
|
||||
@override
|
||||
// TODO(brianwilkerson) Figure out how to get the token (or node) for `this`.
|
||||
// TODO(brianwilkerson) Figure out how to get the property name token (or node).
|
||||
Expression buildSimpleRead() => astFactory.propertyAccess(null, token, null);
|
||||
}
|
||||
|
||||
class AnalyzerTypeUseGenerator extends AnalyzerExpressionGenerator
|
||||
with fasta.TypeUseGenerator<Expression, Statement, Arguments> {
|
||||
final Token token;
|
||||
final fasta.PrefixBuilder prefix;
|
||||
final int declarationReferenceOffset;
|
||||
final fasta.TypeDeclarationBuilder declaration;
|
||||
final String plainNameForRead;
|
||||
|
||||
AnalyzerTypeUseGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
AstFactory astFactory,
|
||||
this.token,
|
||||
this.prefix,
|
||||
this.declarationReferenceOffset,
|
||||
this.declaration,
|
||||
this.plainNameForRead)
|
||||
: super(helper, astFactory);
|
||||
|
||||
@override
|
||||
Expression buildSimpleRead() {
|
||||
// TODO: implement buildSimpleRead
|
||||
throw new UnimplementedError();
|
||||
}
|
||||
}
|
||||
|
||||
class AnalyzerUnlinkedNameGenerator extends AnalyzerExpressionGenerator
|
||||
with fasta.UnlinkedGenerator<Expression, Statement, Arguments> {
|
||||
@override
|
||||
final Token token;
|
||||
|
||||
@override
|
||||
final fasta.UnlinkedDeclaration declaration;
|
||||
|
||||
AnalyzerUnlinkedNameGenerator(
|
||||
ExpressionGeneratorHelper<dynamic, dynamic, dynamic> helper,
|
||||
AstFactory astFactory,
|
||||
this.token,
|
||||
this.declaration)
|
||||
: super(helper, astFactory);
|
||||
|
||||
@override
|
||||
Expression buildSimpleRead() => astFactory.simpleIdentifier(token);
|
||||
}
|
||||
|
||||
class AnalyzerUnresolvedNameGenerator extends AnalyzerExpressionGenerator
|
||||
with
|
||||
fasta.ErroneousExpressionGenerator<Expression, Statement, Arguments>,
|
||||
fasta.UnresolvedNameGenerator<Expression, Statement, Arguments> {
|
||||
@override
|
||||
final Token token;
|
||||
|
||||
@override
|
||||
final kernel.Name name;
|
||||
|
||||
AnalyzerUnresolvedNameGenerator(
|
||||
ExpressionGeneratorHelper<dynamic, dynamic, dynamic> helper,
|
||||
AstFactory astFactory,
|
||||
this.token,
|
||||
this.name)
|
||||
: super(helper, astFactory);
|
||||
|
||||
@override
|
||||
Expression buildSimpleRead() => astFactory.simpleIdentifier(token);
|
||||
}
|
||||
|
||||
class AnalyzerVariableUseGenerator extends AnalyzerExpressionGenerator
|
||||
with fasta.VariableUseGenerator<Expression, Statement, Arguments> {
|
||||
final Token nameToken;
|
||||
|
||||
AnalyzerVariableUseGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
AstFactory astFactory,
|
||||
this.nameToken)
|
||||
: super(helper, astFactory);
|
||||
|
||||
@override
|
||||
Token get token => nameToken;
|
||||
|
||||
@override
|
||||
Expression buildSimpleRead() => astFactory.simpleIdentifier(nameToken);
|
||||
}
|
||||
|
|
@ -1,49 +0,0 @@
|
|||
// Copyright (c) 2018, 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.
|
||||
|
||||
import 'package:analyzer/dart/ast/ast.dart' show Expression, Statement;
|
||||
import 'package:analyzer/src/fasta/ast_building_factory.dart'
|
||||
show Arguments, AstBuildingForest;
|
||||
import 'package:analyzer/src/generated/resolver.dart' show TypeProvider;
|
||||
import 'package:front_end/src/fasta/kernel/body_builder.dart' show BodyBuilder;
|
||||
import 'package:front_end/src/fasta/kernel/kernel_builder.dart'
|
||||
show KernelClassBuilder, KernelLibraryBuilder, ModifierBuilder, Scope;
|
||||
import 'package:front_end/src/fasta/type_inference/type_inferrer.dart'
|
||||
show TypeInferrer;
|
||||
import 'package:kernel/class_hierarchy.dart' show ClassHierarchy;
|
||||
import 'package:kernel/core_types.dart' show CoreTypes;
|
||||
|
||||
export 'package:front_end/src/fasta/kernel/unlinked_scope.dart'
|
||||
show UnlinkedScope;
|
||||
|
||||
class AstBodyBuilder extends BodyBuilder<Expression, Statement, Arguments> {
|
||||
@override
|
||||
final AstBuildingForest forest;
|
||||
|
||||
AstBodyBuilder(
|
||||
KernelLibraryBuilder library,
|
||||
ModifierBuilder member,
|
||||
Scope scope,
|
||||
Scope formalParameterScope,
|
||||
ClassHierarchy hierarchy,
|
||||
CoreTypes coreTypes,
|
||||
KernelClassBuilder classBuilder,
|
||||
bool isInstanceMember,
|
||||
Uri uri,
|
||||
TypeInferrer typeInferrer,
|
||||
TypeProvider typeProvider)
|
||||
: forest = new AstBuildingForest(typeProvider),
|
||||
super(library, member, scope, formalParameterScope, hierarchy,
|
||||
coreTypes, classBuilder, isInstanceMember, uri, typeInferrer);
|
||||
|
||||
@override
|
||||
void enterThenForTypePromotion(Expression condition) {
|
||||
// Do nothing.
|
||||
}
|
||||
|
||||
@override
|
||||
void logEvent(String name) {
|
||||
throw "Parser event '$name' not implemented";
|
||||
}
|
||||
}
|
||||
|
|
@ -1,690 +0,0 @@
|
|||
// Copyright (c) 2018, 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.
|
||||
|
||||
import 'package:analyzer/dart/ast/ast.dart' hide Identifier;
|
||||
import 'package:analyzer/dart/ast/token.dart';
|
||||
import 'package:analyzer/src/dart/ast/ast_factory.dart';
|
||||
import 'package:analyzer/src/fasta/analyzer_expression_generator.dart';
|
||||
import 'package:analyzer/src/generated/resolver.dart' show TypeProvider;
|
||||
import 'package:front_end/src/fasta/kernel/body_builder.dart' show LabelTarget;
|
||||
import 'package:front_end/src/fasta/kernel/forest.dart';
|
||||
import 'package:kernel/ast.dart' as kernel;
|
||||
|
||||
/// A data holder used to conform to the [Forest] API.
|
||||
class Arguments {
|
||||
List<TypeAnnotation> typeArguments = <TypeAnnotation>[];
|
||||
List<Expression> positionalArguments = <Expression>[];
|
||||
List<Expression> namedArguments = <Expression>[];
|
||||
}
|
||||
|
||||
/// An implementation of a [Forest] that can be used to build an AST structure.
|
||||
class AstBuildingForest
|
||||
implements Forest<Expression, Statement, Token, Arguments> {
|
||||
/// The type provider used to resolve the types of literal nodes, or `null` if
|
||||
/// type resolution is not being performed.
|
||||
final TypeProvider _typeProvider;
|
||||
|
||||
/// The factory used to create AST nodes.
|
||||
AstFactoryImpl astFactory = new AstFactoryImpl();
|
||||
|
||||
/// Initialize a newly created AST-building forest.
|
||||
AstBuildingForest(this._typeProvider);
|
||||
|
||||
@override
|
||||
Arguments arguments(List<Expression> positional, Token location,
|
||||
{covariant List types, covariant List named}) {
|
||||
Arguments arguments = new Arguments();
|
||||
if (types != null) {
|
||||
arguments.typeArguments = types.cast<TypeAnnotation>();
|
||||
}
|
||||
arguments.positionalArguments = positional.cast<Expression>();
|
||||
if (named != null) {
|
||||
arguments.namedArguments = named.cast<Expression>();
|
||||
}
|
||||
return arguments;
|
||||
}
|
||||
|
||||
@override
|
||||
Arguments argumentsEmpty(Token location) => new Arguments();
|
||||
|
||||
@override
|
||||
List argumentsNamed(Arguments arguments) => arguments.namedArguments;
|
||||
|
||||
@override
|
||||
List<Expression> argumentsPositional(Arguments arguments) =>
|
||||
arguments.positionalArguments;
|
||||
|
||||
@override
|
||||
void argumentsSetTypeArguments(Arguments arguments, covariant List types) {
|
||||
arguments.typeArguments = types.cast<TypeAnnotation>();
|
||||
}
|
||||
|
||||
@override
|
||||
List argumentsTypeArguments(Arguments arguments) => arguments.typeArguments;
|
||||
|
||||
@override
|
||||
Expression asExpression(Expression expression, type, Token location) =>
|
||||
astFactory.asExpression(expression, location, type);
|
||||
|
||||
@override
|
||||
Expression asLiteralString(Expression value) => value;
|
||||
|
||||
@override
|
||||
ConstructorInitializer assertInitializer(
|
||||
Token assertKeyword,
|
||||
Token leftParenthesis,
|
||||
Expression condition,
|
||||
Token comma,
|
||||
Expression message) =>
|
||||
astFactory.assertInitializer(assertKeyword, leftParenthesis, condition,
|
||||
comma, message, leftParenthesis.endGroup);
|
||||
|
||||
@override
|
||||
Statement assertStatement(
|
||||
Token assertKeyword,
|
||||
Token leftParenthesis,
|
||||
Expression condition,
|
||||
Token comma,
|
||||
Expression message,
|
||||
Token semicolon) =>
|
||||
astFactory.assertStatement(assertKeyword, leftParenthesis, condition,
|
||||
comma, message, leftParenthesis.endGroup, semicolon);
|
||||
|
||||
@override
|
||||
Expression awaitExpression(Expression operand, Token awaitKeyword) =>
|
||||
astFactory.awaitExpression(awaitKeyword, operand);
|
||||
|
||||
@override
|
||||
Block block(Token openBrace, List<Statement> statements, Token closeBrace) =>
|
||||
astFactory.block(openBrace, statements, closeBrace);
|
||||
|
||||
@override
|
||||
Statement breakStatement(
|
||||
Token breakKeyword, Identifier label, Token semicolon) =>
|
||||
astFactory.breakStatement(
|
||||
breakKeyword,
|
||||
label == null ? null : astFactory.simpleIdentifier(label.token),
|
||||
semicolon);
|
||||
|
||||
@override
|
||||
kernel.Arguments castArguments(Arguments arguments) {
|
||||
// TODO(brianwilkerson) Implement this or remove it from the API.
|
||||
throw new UnimplementedError();
|
||||
}
|
||||
|
||||
@override
|
||||
CatchClause catchClause(
|
||||
Token onKeyword,
|
||||
TypeAnnotation exceptionType,
|
||||
Token catchKeyword,
|
||||
SimpleIdentifier exceptionParameter,
|
||||
SimpleIdentifier stackTraceParameter,
|
||||
TypeAnnotation stackTraceType,
|
||||
Statement body) {
|
||||
// TODO(brianwilkerson) The following is not reliable in the presence of
|
||||
// recovery. Consider passing the required tokens from the Parser to the
|
||||
// BodyBuilder to here.
|
||||
Token leftParenthesis;
|
||||
if (catchKeyword != null) {
|
||||
leftParenthesis = catchKeyword.next;
|
||||
}
|
||||
Token comma;
|
||||
if (stackTraceParameter != null) {
|
||||
comma = exceptionParameter.endToken.next;
|
||||
}
|
||||
Token rightParenthesis;
|
||||
if (catchKeyword != null) {
|
||||
if (stackTraceParameter != null) {
|
||||
rightParenthesis = stackTraceParameter.endToken.next;
|
||||
} else if (comma != null) {
|
||||
rightParenthesis = comma.next;
|
||||
} else {
|
||||
rightParenthesis = exceptionParameter.endToken.next;
|
||||
}
|
||||
}
|
||||
return astFactory.catchClause(
|
||||
onKeyword,
|
||||
exceptionType,
|
||||
catchKeyword,
|
||||
leftParenthesis,
|
||||
exceptionParameter,
|
||||
comma,
|
||||
stackTraceParameter,
|
||||
rightParenthesis,
|
||||
body);
|
||||
}
|
||||
|
||||
@override
|
||||
Expression checkLibraryIsLoaded(dependency) {
|
||||
// TODO(brianwilkerson) Implement this.
|
||||
throw new UnimplementedError();
|
||||
}
|
||||
|
||||
@override
|
||||
Expression conditionalExpression(Expression condition, Token question,
|
||||
Expression thenExpression, Token colon, Expression elseExpression) =>
|
||||
astFactory.conditionalExpression(
|
||||
condition, question, thenExpression, colon, elseExpression);
|
||||
|
||||
@override
|
||||
Statement continueStatement(
|
||||
Token continueKeyword, Identifier label, Token semicolon) =>
|
||||
astFactory.continueStatement(
|
||||
continueKeyword,
|
||||
label == null ? null : astFactory.simpleIdentifier(label.token),
|
||||
semicolon);
|
||||
|
||||
@override
|
||||
Generator<Expression, Statement, Arguments> deferredAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token,
|
||||
PrefixBuilder builder,
|
||||
Generator<Expression, Statement, Arguments> generator) {
|
||||
return new AnalyzerDeferredAccessGenerator(
|
||||
helper, astFactory, token, builder, generator);
|
||||
}
|
||||
|
||||
@override
|
||||
Generator<Expression, Statement, Arguments> delayedAssignment(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token,
|
||||
Generator<Expression, Statement, Arguments> generator,
|
||||
Expression value,
|
||||
String assignmentOperator) {
|
||||
return new AnalyzerDelayedAssignmentGenerator(
|
||||
helper, astFactory, token, generator, assignmentOperator, value);
|
||||
}
|
||||
|
||||
@override
|
||||
Generator<Expression, Statement, Arguments> delayedPostfixIncrement(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token,
|
||||
Generator<Expression, Statement, Arguments> generator,
|
||||
kernel.Name binaryOperator,
|
||||
kernel.Procedure interfaceTarget) {
|
||||
return new AnalyzerDelayedPostfixIncrementGenerator(
|
||||
helper, astFactory, token, generator, binaryOperator, interfaceTarget);
|
||||
}
|
||||
|
||||
@override
|
||||
Statement doStatement(Token doKeyword, Statement body, Token whileKeyword,
|
||||
ParenthesizedExpression condition, Token semicolon) =>
|
||||
astFactory.doStatement(
|
||||
doKeyword,
|
||||
body,
|
||||
whileKeyword,
|
||||
condition.leftParenthesis,
|
||||
condition.expression,
|
||||
condition.rightParenthesis,
|
||||
semicolon);
|
||||
|
||||
@override
|
||||
Statement emptyStatement(Token semicolon) =>
|
||||
astFactory.emptyStatement(semicolon);
|
||||
|
||||
@override
|
||||
Statement expressionStatement(Expression expression, Token semicolon) =>
|
||||
astFactory.expressionStatement(expression, semicolon);
|
||||
|
||||
@override
|
||||
Statement forStatement(
|
||||
Token forKeyword,
|
||||
Token leftParenthesis,
|
||||
covariant variableList,
|
||||
covariant initialization,
|
||||
Token leftSeparator,
|
||||
Expression condition,
|
||||
Statement conditionStatement,
|
||||
List<Expression> updaters,
|
||||
Token rightParenthesis,
|
||||
Statement body) =>
|
||||
astFactory.forStatement(
|
||||
forKeyword,
|
||||
leftParenthesis,
|
||||
variableList,
|
||||
initialization,
|
||||
leftSeparator,
|
||||
condition,
|
||||
getSemicolon(conditionStatement),
|
||||
updaters,
|
||||
rightParenthesis,
|
||||
body);
|
||||
|
||||
@override
|
||||
Expression getExpressionFromExpressionStatement(Statement statement) =>
|
||||
(statement as ExpressionStatement).expression;
|
||||
|
||||
String getLabelName(Label label) => label.label.name;
|
||||
|
||||
@override
|
||||
int getLabelOffset(Label label) => label.offset;
|
||||
|
||||
/// Return the semicolon at the end of the given [statement], or `null` if the
|
||||
/// statement is not terminated by a semicolon.
|
||||
Token getSemicolon(Statement statement) {
|
||||
if (statement is ExpressionStatement) {
|
||||
return statement.semicolon;
|
||||
}
|
||||
if (statement is EmptyStatement) {
|
||||
return statement.semicolon;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
@override
|
||||
kernel.DartType getTypeAt(TypeArgumentList typeArguments, int index) {
|
||||
return null; // typeArguments.arguments[index].type.kernelType;
|
||||
}
|
||||
|
||||
@override
|
||||
int getTypeCount(TypeArgumentList typeArguments) =>
|
||||
typeArguments.arguments.length;
|
||||
|
||||
@override
|
||||
String getVariableDeclarationName(VariableDeclaration declaration) {
|
||||
return declaration.name.name;
|
||||
}
|
||||
|
||||
@override
|
||||
Statement ifStatement(
|
||||
Token ifKeyword,
|
||||
ParenthesizedExpression condition,
|
||||
Statement thenStatement,
|
||||
Token elseKeyword,
|
||||
Statement elseStatement) =>
|
||||
astFactory.ifStatement(
|
||||
ifKeyword,
|
||||
condition.leftParenthesis,
|
||||
condition.expression,
|
||||
condition.rightParenthesis,
|
||||
thenStatement,
|
||||
elseKeyword,
|
||||
elseStatement);
|
||||
|
||||
@override
|
||||
Generator<Expression, Statement, Arguments> indexedAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token,
|
||||
Expression receiver,
|
||||
Expression index,
|
||||
kernel.Procedure getter,
|
||||
kernel.Procedure setter) {
|
||||
return new AnalyzerIndexedAccessGenerator(
|
||||
helper, astFactory, receiver, token, index, token.endGroup);
|
||||
}
|
||||
|
||||
@override
|
||||
bool isBlock(Object node) => node is Block;
|
||||
|
||||
@override
|
||||
bool isEmptyStatement(Statement statement) => statement is EmptyStatement;
|
||||
|
||||
@override
|
||||
bool isErroneousNode(Object node) => false /* ??? */;
|
||||
|
||||
@override
|
||||
Expression isExpression(Expression expression, Token isOperator,
|
||||
Token notOperator, Object type) =>
|
||||
astFactory.isExpression(expression, isOperator, notOperator, type);
|
||||
|
||||
@override
|
||||
bool isExpressionStatement(Statement statement) =>
|
||||
statement is ExpressionStatement;
|
||||
|
||||
@override
|
||||
bool isLabel(covariant node) => node is Label;
|
||||
|
||||
@override
|
||||
bool isThisExpression(Object node) => node is ThisExpression;
|
||||
|
||||
@override
|
||||
bool isVariablesDeclaration(Object node) =>
|
||||
node is VariableDeclarationStatement && node.variables != 1;
|
||||
|
||||
@override
|
||||
Label label(Token identifier, Token colon) => astFactory.label(
|
||||
astFactory.simpleIdentifier(identifier, isDeclaration: true), colon);
|
||||
|
||||
@override
|
||||
Statement labeledStatement(
|
||||
LabelTarget<Statement> target, Statement statement) =>
|
||||
astFactory.labeledStatement(target.labels.cast<Label>(), statement);
|
||||
|
||||
@override
|
||||
Generator<Expression, Statement, Arguments> largeIntAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token) {
|
||||
return new AnalyzerLargeIntAccessGenerator(helper, astFactory, token);
|
||||
}
|
||||
|
||||
@override
|
||||
Expression literalBool(bool value, Token location) =>
|
||||
astFactory.booleanLiteral(location, value)
|
||||
..staticType = _typeProvider?.boolType;
|
||||
|
||||
@override
|
||||
Expression literalDouble(double value, Token location) =>
|
||||
astFactory.doubleLiteral(location, value)
|
||||
..staticType = _typeProvider?.doubleType;
|
||||
|
||||
@override
|
||||
Expression literalInt(int value, Token location) =>
|
||||
astFactory.integerLiteral(location, value)
|
||||
..staticType = _typeProvider?.intType;
|
||||
|
||||
@override
|
||||
Expression literalList(
|
||||
Token constKeyword,
|
||||
bool isConst,
|
||||
Object typeArgument,
|
||||
Object typeArguments,
|
||||
Token leftBracket,
|
||||
List<Expression> expressions,
|
||||
Token rightBracket) =>
|
||||
astFactory.listLiteral(
|
||||
constKeyword, typeArguments, leftBracket, expressions, rightBracket);
|
||||
|
||||
@override
|
||||
Expression literalMap(
|
||||
Token constKeyword,
|
||||
bool isConst,
|
||||
covariant keyType,
|
||||
covariant valueType,
|
||||
Object typeArguments,
|
||||
Token leftBracket,
|
||||
covariant List entries,
|
||||
Token rightBracket) =>
|
||||
astFactory.mapLiteral(
|
||||
constKeyword, typeArguments, leftBracket, entries, rightBracket);
|
||||
|
||||
@override
|
||||
Expression literalNull(Token location) =>
|
||||
astFactory.nullLiteral(location)..staticType = _typeProvider?.nullType;
|
||||
|
||||
@override
|
||||
Expression literalString(String value, Token location) =>
|
||||
astFactory.simpleStringLiteral(location, value)
|
||||
..staticType = _typeProvider?.stringType;
|
||||
|
||||
@override
|
||||
Expression literalSymbolMultiple(
|
||||
String value, Token hash, List<Identifier> components) =>
|
||||
astFactory.symbolLiteral(
|
||||
hash, components.map((identifier) => identifier.token).toList())
|
||||
..staticType = _typeProvider?.symbolType;
|
||||
|
||||
@override
|
||||
Expression literalSymbolSingluar(String value, Token hash, Object component) {
|
||||
Token token;
|
||||
if (component is Identifier) {
|
||||
token = component.token;
|
||||
} else if (component is Operator) {
|
||||
token = component.token;
|
||||
} else {
|
||||
throw new ArgumentError(
|
||||
'Unexpected class of component: ${component.runtimeType}');
|
||||
}
|
||||
return astFactory.symbolLiteral(hash, <Token>[token])
|
||||
..staticType = _typeProvider?.symbolType;
|
||||
}
|
||||
|
||||
@override
|
||||
Expression literalType(covariant type, Token location) {
|
||||
// TODO(brianwilkerson) Capture the type information.
|
||||
return astFactory.simpleIdentifier(location)
|
||||
..staticType = _typeProvider?.typeType;
|
||||
}
|
||||
|
||||
@override
|
||||
Expression loadLibrary(dependency) {
|
||||
// TODO(brianwilkerson) Implement this.
|
||||
throw new UnimplementedError();
|
||||
}
|
||||
|
||||
@override
|
||||
Generator<Expression, Statement, Arguments> loadLibraryGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token,
|
||||
LoadLibraryBuilder builder) {
|
||||
return new AnalyzerLoadLibraryGenerator(helper, astFactory, token, builder);
|
||||
}
|
||||
|
||||
@override
|
||||
Expression logicalExpression(
|
||||
Expression leftOperand, Token operator, Expression rightOperand) =>
|
||||
astFactory.binaryExpression(leftOperand, operator, rightOperand);
|
||||
|
||||
@override
|
||||
Object mapEntry(Expression key, Token colon, Expression value) =>
|
||||
astFactory.mapLiteralEntry(key, colon, value);
|
||||
|
||||
@override
|
||||
List mapEntryList(int length) => new List<MapLiteralEntry>(length);
|
||||
|
||||
@override
|
||||
Expression notExpression(Expression operand, Token operator) =>
|
||||
astFactory.prefixExpression(operator, operand)
|
||||
..staticType = _typeProvider?.boolType;
|
||||
|
||||
@override
|
||||
Generator<Expression, Statement, Arguments> nullAwarePropertyAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token,
|
||||
Expression receiverExpression,
|
||||
kernel.Name name,
|
||||
kernel.Member getter,
|
||||
kernel.Member setter,
|
||||
kernel.DartType type) {
|
||||
return new AnalyzerNullAwarePropertyAccessGenerator(
|
||||
helper, astFactory, receiverExpression, token, null /*name*/);
|
||||
}
|
||||
|
||||
@override
|
||||
Object parenthesizedCondition(Token leftParenthesis, Expression expression,
|
||||
Token rightParenthesis) =>
|
||||
astFactory.parenthesizedExpression(
|
||||
leftParenthesis, expression, rightParenthesis);
|
||||
|
||||
@override
|
||||
Generator<Expression, Statement, Arguments> propertyAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token,
|
||||
Expression receiver,
|
||||
kernel.Name name,
|
||||
kernel.Member getter,
|
||||
kernel.Member setter) {
|
||||
return new AnalyzerPropertyAccessGenerator(
|
||||
helper, astFactory, token, receiver, name, getter, setter);
|
||||
}
|
||||
|
||||
@override
|
||||
int readOffset(AstNode node) => node.offset;
|
||||
|
||||
@override
|
||||
Generator<Expression, Statement, Arguments> readOnlyAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token,
|
||||
Expression expression,
|
||||
String plainNameForRead) {
|
||||
return new AnalyzerReadOnlyAccessGenerator(
|
||||
helper, astFactory, token, expression, plainNameForRead);
|
||||
}
|
||||
|
||||
@override
|
||||
void resolveBreak(Statement target, BreakStatement user) {
|
||||
user.target = target;
|
||||
}
|
||||
|
||||
@override
|
||||
void resolveContinue(Statement target, ContinueStatement user) {
|
||||
user.target = target;
|
||||
}
|
||||
|
||||
@override
|
||||
void resolveContinueInSwitch(SwitchStatement target, ContinueStatement user) {
|
||||
user.target = target;
|
||||
}
|
||||
|
||||
@override
|
||||
Statement rethrowStatement(Token rethrowKeyword, Token semicolon) =>
|
||||
astFactory.expressionStatement(
|
||||
astFactory.rethrowExpression(rethrowKeyword), semicolon);
|
||||
|
||||
@override
|
||||
Statement returnStatement(
|
||||
Token returnKeyword, Expression expression, Token semicolon) =>
|
||||
astFactory.returnStatement(returnKeyword, expression, semicolon);
|
||||
|
||||
@override
|
||||
void setParameterType(FormalParameter parameter, TypeAnnotation type) {
|
||||
parameter.identifier.staticType = type.type;
|
||||
}
|
||||
|
||||
@override
|
||||
Generator<Expression, Statement, Arguments> staticAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token,
|
||||
kernel.Member getter,
|
||||
kernel.Member setter) {
|
||||
return new AnalyzerStaticAccessGenerator(
|
||||
helper, astFactory, token, getter, setter);
|
||||
}
|
||||
|
||||
@override
|
||||
Expression stringConcatenationExpression(
|
||||
List<Expression> strings, Token location) =>
|
||||
astFactory.adjacentStrings(strings.cast<StringLiteral>());
|
||||
|
||||
@override
|
||||
Generator<Expression, Statement, Arguments> superIndexedAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token,
|
||||
Expression index,
|
||||
kernel.Member getter,
|
||||
kernel.Member setter) {
|
||||
// TODO(brianwilkerson) Figure out how to get the token for `super`.
|
||||
return new AnalyzerIndexedAccessGenerator(
|
||||
helper, astFactory, null, token, index, token.endGroup);
|
||||
}
|
||||
|
||||
@override
|
||||
Generator<Expression, Statement, Arguments> superPropertyAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token,
|
||||
kernel.Name name,
|
||||
kernel.Member getter,
|
||||
kernel.Member setter) {
|
||||
// TODO(brianwilkerson) Figure out how to get the token for the name.
|
||||
return new AnalyzerSuperPropertyAccessGenerator(
|
||||
helper, astFactory, null, null, null /*name*/);
|
||||
}
|
||||
|
||||
@override
|
||||
Statement syntheticLabeledStatement(Statement statement) => statement;
|
||||
|
||||
@override
|
||||
Expression thisExpression(Token thisKeyword) =>
|
||||
astFactory.thisExpression(thisKeyword);
|
||||
|
||||
@override
|
||||
Generator<Expression, Statement, Arguments> thisIndexedAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token,
|
||||
Expression index,
|
||||
kernel.Procedure getter,
|
||||
kernel.Procedure setter) {
|
||||
// TODO(brianwilkerson) Figure out how to get the token for `this`.
|
||||
return new AnalyzerIndexedAccessGenerator(
|
||||
helper, astFactory, null, token, index, token.endGroup);
|
||||
}
|
||||
|
||||
@override
|
||||
Generator<Expression, Statement, Arguments> thisPropertyAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token location,
|
||||
kernel.Name name,
|
||||
kernel.Member getter,
|
||||
kernel.Member setter) {
|
||||
// TODO(brianwilkerson) Figure out how to get the token for the name.
|
||||
return new AnalyzerThisPropertyAccessGenerator(
|
||||
helper, astFactory, location, name, getter, setter);
|
||||
}
|
||||
|
||||
@override
|
||||
Expression throwExpression(Token throwKeyword, Expression expression) =>
|
||||
astFactory.throwExpression(throwKeyword, expression);
|
||||
|
||||
@override
|
||||
Statement tryStatement(
|
||||
Token tryKeyword,
|
||||
Statement body,
|
||||
List<CatchClause> catchClauses,
|
||||
Token finallyKeyword,
|
||||
Statement finallyBlock) =>
|
||||
astFactory.tryStatement(
|
||||
tryKeyword, body, catchClauses, finallyKeyword, finallyBlock);
|
||||
|
||||
@override
|
||||
Generator<Expression, Statement, Arguments> typeUseGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token,
|
||||
PrefixBuilder prefix,
|
||||
int declarationReferenceOffset,
|
||||
TypeDeclarationBuilder declaration,
|
||||
String plainNameForRead) {
|
||||
return new AnalyzerTypeUseGenerator(helper, astFactory, token, prefix,
|
||||
declarationReferenceOffset, declaration, plainNameForRead);
|
||||
}
|
||||
|
||||
@override
|
||||
Generator<Expression, Statement, Arguments> unlinkedGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token,
|
||||
UnlinkedDeclaration declaration) {
|
||||
return new AnalyzerUnlinkedNameGenerator(
|
||||
helper, astFactory, token, declaration);
|
||||
}
|
||||
|
||||
@override
|
||||
Generator<Expression, Statement, Arguments> unresolvedNameGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token,
|
||||
kernel.Name name) {
|
||||
return new AnalyzerUnresolvedNameGenerator(helper, astFactory, token, name);
|
||||
}
|
||||
|
||||
@override
|
||||
VariableDeclarationStatement variablesDeclaration(
|
||||
List<VariableDeclaration> declarations, Uri uri) {
|
||||
// TODO(brianwilkerson) Implement this.
|
||||
throw new UnimplementedError();
|
||||
}
|
||||
|
||||
@override
|
||||
NodeList<VariableDeclaration> variablesDeclarationExtractDeclarations(
|
||||
VariableDeclarationStatement variablesDeclaration) =>
|
||||
variablesDeclaration.variables.variables;
|
||||
|
||||
@override
|
||||
Generator<Expression, Statement, Arguments> variableUseGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token,
|
||||
VariableDeclarationStatement variable,
|
||||
kernel.DartType promotedType) {
|
||||
return new AnalyzerVariableUseGenerator(helper, astFactory, token);
|
||||
}
|
||||
|
||||
Statement whileStatement(Token whileKeyword,
|
||||
ParenthesizedExpression condition, Statement body) =>
|
||||
astFactory.whileStatement(whileKeyword, condition.leftParenthesis,
|
||||
condition.expression, condition.rightParenthesis, body);
|
||||
|
||||
@override
|
||||
Statement wrapVariables(Statement statement) => statement;
|
||||
|
||||
@override
|
||||
Statement yieldStatement(Token yieldKeyword, Token star,
|
||||
Expression expression, Token semicolon) =>
|
||||
astFactory.yieldStatement(yieldKeyword, star, expression, semicolon);
|
||||
}
|
||||
File diff suppressed because it is too large
Load diff
|
|
@ -42,7 +42,6 @@ import 'non_hint_code_kernel_test.dart' as non_hint_code_kernel_test;
|
|||
import 'non_hint_code_test.dart' as non_hint_code_test;
|
||||
import 'package_test.dart' as package_test;
|
||||
import 'parser_fasta_test.dart' as parser_fasta_test;
|
||||
import 'parser_forest_test.dart' as parser_forest_test;
|
||||
import 'parser_test.dart' as parser_test;
|
||||
import 'resolver_driver_test.dart' as resolver_driver_test;
|
||||
import 'resolver_kernel_test.dart' as resolver_kernel_test;
|
||||
|
|
@ -108,7 +107,6 @@ main() {
|
|||
non_hint_code_test.main();
|
||||
package_test.main();
|
||||
parser_fasta_test.main();
|
||||
parser_forest_test.main();
|
||||
parser_test.main();
|
||||
resolver_driver_test.main();
|
||||
resolver_kernel_test.main();
|
||||
|
|
|
|||
|
|
@ -5,41 +5,24 @@
|
|||
import 'dart:async';
|
||||
import 'dart:io' show File;
|
||||
|
||||
import 'package:analyzer/analyzer.dart';
|
||||
import 'package:analyzer/dart/ast/ast.dart';
|
||||
import 'package:analyzer/dart/element/element.dart';
|
||||
import 'package:analyzer/src/dart/element/element.dart';
|
||||
import 'package:analyzer/src/dart/element/type.dart';
|
||||
import 'package:analyzer/src/fasta/ast_body_builder.dart';
|
||||
import 'package:analyzer/src/generated/parser.dart' as analyzer;
|
||||
import 'package:analyzer/src/generated/resolver.dart';
|
||||
import "package:front_end/src/api_prototype/front_end.dart";
|
||||
import "package:front_end/src/api_prototype/memory_file_system.dart";
|
||||
import "package:front_end/src/base/processed_options.dart";
|
||||
import "package:front_end/src/compute_platform_binaries_location.dart";
|
||||
import 'package:front_end/src/fasta/compiler_context.dart';
|
||||
import 'package:front_end/src/fasta/constant_context.dart';
|
||||
import 'package:front_end/src/fasta/dill/dill_target.dart';
|
||||
import "package:front_end/src/fasta/fasta_codes.dart";
|
||||
import 'package:front_end/src/fasta/kernel/forest.dart' hide Identifier;
|
||||
import 'package:front_end/src/fasta/kernel/kernel_builder.dart';
|
||||
import "package:front_end/src/fasta/kernel/kernel_target.dart";
|
||||
import 'package:front_end/src/fasta/modifier.dart' as Modifier;
|
||||
import 'package:front_end/src/fasta/parser/async_modifier.dart';
|
||||
import 'package:front_end/src/fasta/parser/parser.dart';
|
||||
import 'package:front_end/src/fasta/scanner.dart';
|
||||
import 'package:front_end/src/fasta/ticker.dart';
|
||||
import 'package:front_end/src/fasta/type_inference/type_inferrer.dart';
|
||||
import 'package:front_end/src/fasta/type_inference/type_schema_environment.dart';
|
||||
import 'package:front_end/src/fasta/uri_translator_impl.dart';
|
||||
import 'package:kernel/class_hierarchy.dart' as kernel;
|
||||
import 'package:kernel/core_types.dart' as kernel;
|
||||
import 'package:kernel/kernel.dart' as kernel;
|
||||
import 'package:test/test.dart';
|
||||
|
||||
import '../../generated/parser_test.dart';
|
||||
import '../../generated/test_support.dart';
|
||||
|
||||
Element _buildElement(kernel.Class coreType) {
|
||||
ClassElementImpl element =
|
||||
new ClassElementImpl(coreType.name, coreType.fileOffset);
|
||||
|
|
@ -54,7 +37,6 @@ Element _buildElement(kernel.Class coreType) {
|
|||
|
||||
class CompilerTestContext extends CompilerContext {
|
||||
KernelTarget kernelTarget;
|
||||
TypeProvider _typeProvider;
|
||||
|
||||
CompilerTestContext(ProcessedOptions options) : super(options);
|
||||
|
||||
|
|
@ -139,9 +121,6 @@ class CompilerTestContext extends CompilerContext {
|
|||
]) {
|
||||
map[coreType.name] = _buildElement(coreType);
|
||||
}
|
||||
Namespace namespace = new Namespace(map);
|
||||
c._typeProvider =
|
||||
new TypeProviderImpl.forNamespaces(namespace, namespace);
|
||||
|
||||
T result;
|
||||
Completer<T> completer = new Completer<T>();
|
||||
|
|
@ -160,652 +139,3 @@ class CompilerTestContext extends CompilerContext {
|
|||
|
||||
static CompilerTestContext get current => CompilerContext.current;
|
||||
}
|
||||
|
||||
/// Implementation of [AbstractParserTestCase] specialized for testing building
|
||||
/// Analyzer AST using the fasta [Forest] API.
|
||||
class FastaBodyBuilderTestCase extends Object
|
||||
with ParserTestHelpers
|
||||
implements AbstractParserTestCase {
|
||||
final bool resolveTypes;
|
||||
|
||||
String content;
|
||||
|
||||
/// The expected offset of the next token to be parsed after the parser has
|
||||
/// finished parsing, or `null` (the default) if EOF is expected.
|
||||
int expectedEndOffset;
|
||||
|
||||
@override
|
||||
void set enableGenericMethodComments(_) {
|
||||
// Ignored.
|
||||
}
|
||||
|
||||
FastaBodyBuilderTestCase(this.resolveTypes);
|
||||
|
||||
analyzer.Parser get parser => new ParserProxy(this);
|
||||
|
||||
TypeProvider get typeProvider => CompilerTestContext.current._typeProvider;
|
||||
|
||||
bool get usingFastaParser => true;
|
||||
|
||||
@override
|
||||
void assertNoErrors() {
|
||||
// TODO(brianwilkerson) Implement this.
|
||||
}
|
||||
|
||||
void createParser(String content, {int expectedEndOffset}) {
|
||||
this.content = content;
|
||||
this.expectedEndOffset = expectedEndOffset;
|
||||
}
|
||||
|
||||
@override
|
||||
void expectNotNullIfNoErrors(Object result) {
|
||||
// TODO(brianwilkerson) Implement this.
|
||||
}
|
||||
|
||||
@override
|
||||
ExpectedError expectedError(ErrorCode code, int offset, int length) {
|
||||
return new ExpectedError(code, offset, length);
|
||||
}
|
||||
|
||||
noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
|
||||
|
||||
@override
|
||||
Expression parseAdditiveExpression(String code) {
|
||||
return parseExpression(code);
|
||||
}
|
||||
|
||||
@override
|
||||
Expression parseAssignableExpression(String code, bool primaryAllowed) {
|
||||
return parseExpression(code);
|
||||
}
|
||||
|
||||
@override
|
||||
Expression parseAssignableSelector(String code, bool optional,
|
||||
{bool allowConditional: true}) {
|
||||
return parseExpression(code);
|
||||
}
|
||||
|
||||
@override
|
||||
AwaitExpression parseAwaitExpression(String code) {
|
||||
return parseExpression(code, inAsync: true);
|
||||
}
|
||||
|
||||
@override
|
||||
Expression parseBitwiseAndExpression(String code) {
|
||||
return parseExpression(code);
|
||||
}
|
||||
|
||||
@override
|
||||
Expression parseBitwiseOrExpression(String code) {
|
||||
return parseExpression(code);
|
||||
}
|
||||
|
||||
@override
|
||||
Expression parseBitwiseXorExpression(String code) {
|
||||
return parseExpression(code);
|
||||
}
|
||||
|
||||
@override
|
||||
Expression parseCascadeSection(String code) {
|
||||
return parseExpression(code);
|
||||
}
|
||||
|
||||
@override
|
||||
CompilationUnit parseCompilationUnit(String source,
|
||||
{List<ErrorCode> codes, List<ExpectedError> errors}) {
|
||||
return _parse(source, (parser, token) => parser.parseUnit(token.next));
|
||||
}
|
||||
|
||||
@override
|
||||
ConditionalExpression parseConditionalExpression(String code) {
|
||||
return parseExpression(code);
|
||||
}
|
||||
|
||||
@override
|
||||
Expression parseConstExpression(String code) {
|
||||
return parseExpression(code);
|
||||
}
|
||||
|
||||
@override
|
||||
ConstructorInitializer parseConstructorInitializer(String code) {
|
||||
throw new UnimplementedError();
|
||||
}
|
||||
|
||||
@override
|
||||
CompilationUnit parseDirectives(String source,
|
||||
[List<ErrorCode> errorCodes = const <ErrorCode>[]]) {
|
||||
return parseCompilationUnit(content, codes: errorCodes);
|
||||
}
|
||||
|
||||
@override
|
||||
BinaryExpression parseEqualityExpression(String code) {
|
||||
return parseExpression(code);
|
||||
}
|
||||
|
||||
@override
|
||||
Expression parseExpression(String source,
|
||||
{List<ErrorCode> codes,
|
||||
List<ExpectedError> errors,
|
||||
int expectedEndOffset,
|
||||
bool inAsync: false,
|
||||
bool inCatchBlock: false}) {
|
||||
// TODO(brianwilkerson) Check error codes.
|
||||
Object result = _parse(
|
||||
source, (parser, token) => parser.parseExpression(token),
|
||||
inAsync: inAsync, inCatchBlock: inCatchBlock);
|
||||
if (result is Generator) {
|
||||
result = (result as Generator).buildForEffect();
|
||||
}
|
||||
if (result is! Expression) {
|
||||
throw new StateError('Expected Expression, found ${result.runtimeType}');
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
@override
|
||||
List<Expression> parseExpressionList(String code) {
|
||||
throw new UnimplementedError();
|
||||
}
|
||||
|
||||
@override
|
||||
Expression parseExpressionWithoutCascade(String code) {
|
||||
return parseExpression(code);
|
||||
}
|
||||
|
||||
@override
|
||||
FormalParameter parseFormalParameter(String code, ParameterKind kind,
|
||||
{List<ErrorCode> errorCodes: const <ErrorCode>[]}) {
|
||||
throw new UnimplementedError();
|
||||
}
|
||||
|
||||
@override
|
||||
FormalParameterList parseFormalParameterList(String code,
|
||||
{bool inFunctionType: false,
|
||||
List<ErrorCode> errorCodes: const <ErrorCode>[],
|
||||
List<ExpectedError> errors}) {
|
||||
throw new UnimplementedError();
|
||||
}
|
||||
|
||||
@override
|
||||
CompilationUnitMember parseFullCompilationUnitMember() {
|
||||
CompilationUnit unit = parseCompilationUnit(content);
|
||||
expect(unit.directives, hasLength(0));
|
||||
expect(unit.declarations, hasLength(1));
|
||||
return unit.declarations[0];
|
||||
}
|
||||
|
||||
@override
|
||||
Directive parseFullDirective() {
|
||||
CompilationUnit unit = parseCompilationUnit(content);
|
||||
expect(unit.directives, hasLength(1));
|
||||
expect(unit.declarations, hasLength(0));
|
||||
return unit.directives[0];
|
||||
}
|
||||
|
||||
@override
|
||||
FunctionExpression parseFunctionExpression(String code) {
|
||||
return parseExpression(code);
|
||||
}
|
||||
|
||||
@override
|
||||
InstanceCreationExpression parseInstanceCreationExpression(
|
||||
String code, Token newToken) {
|
||||
return parseExpression(code);
|
||||
}
|
||||
|
||||
@override
|
||||
ListLiteral parseListLiteral(
|
||||
Token token, String typeArgumentsCode, String code) {
|
||||
StringBuffer buffer = new StringBuffer();
|
||||
if (token != null) {
|
||||
buffer.write(token.lexeme);
|
||||
buffer.write(' ');
|
||||
}
|
||||
if (typeArgumentsCode != null) {
|
||||
buffer.write(typeArgumentsCode);
|
||||
}
|
||||
buffer.write(code);
|
||||
return parseExpression(buffer.toString());
|
||||
}
|
||||
|
||||
@override
|
||||
TypedLiteral parseListOrMapLiteral(Token modifier, String code) {
|
||||
return parseExpression(code);
|
||||
}
|
||||
|
||||
@override
|
||||
Expression parseLogicalAndExpression(String code) {
|
||||
return parseExpression(code);
|
||||
}
|
||||
|
||||
@override
|
||||
Expression parseLogicalOrExpression(String code) {
|
||||
return parseExpression(code);
|
||||
}
|
||||
|
||||
@override
|
||||
MapLiteral parseMapLiteral(
|
||||
Token token, String typeArgumentsCode, String code) {
|
||||
StringBuffer buffer = new StringBuffer();
|
||||
if (token != null) {
|
||||
buffer.write(token.lexeme);
|
||||
buffer.write(' ');
|
||||
}
|
||||
if (typeArgumentsCode != null) {
|
||||
buffer.write(typeArgumentsCode);
|
||||
}
|
||||
buffer.write(code);
|
||||
return parseExpression(buffer.toString());
|
||||
}
|
||||
|
||||
@override
|
||||
MapLiteralEntry parseMapLiteralEntry(String code) {
|
||||
Expression expression = parseExpression('{$code}');
|
||||
expect(expression, new isInstanceOf<MapLiteral>());
|
||||
MapLiteral literal = expression;
|
||||
expect(literal.entries, hasLength(1));
|
||||
return literal.entries[0];
|
||||
}
|
||||
|
||||
@override
|
||||
Expression parseMultiplicativeExpression(String code) {
|
||||
return parseExpression(code);
|
||||
}
|
||||
|
||||
@override
|
||||
InstanceCreationExpression parseNewExpression(String code) {
|
||||
return parseExpression(code);
|
||||
}
|
||||
|
||||
@override
|
||||
NormalFormalParameter parseNormalFormalParameter(String code,
|
||||
{bool inFunctionType: false,
|
||||
List<ErrorCode> errorCodes: const <ErrorCode>[]}) {
|
||||
throw new UnimplementedError();
|
||||
}
|
||||
|
||||
@override
|
||||
Expression parsePostfixExpression(String code) {
|
||||
return parseExpression(code);
|
||||
}
|
||||
|
||||
@override
|
||||
Identifier parsePrefixedIdentifier(String code) {
|
||||
return parseExpression(code);
|
||||
}
|
||||
|
||||
@override
|
||||
Expression parsePrimaryExpression(String code,
|
||||
{int expectedEndOffset, List<ExpectedError> errors}) {
|
||||
return parseExpression(code,
|
||||
expectedEndOffset: expectedEndOffset, errors: errors);
|
||||
}
|
||||
|
||||
@override
|
||||
Expression parseRelationalExpression(String code) {
|
||||
return parseExpression(code);
|
||||
}
|
||||
|
||||
@override
|
||||
RethrowExpression parseRethrowExpression(String code) {
|
||||
Statement statement = parseStatement(code, inCatchBlock: true);
|
||||
expect(statement, new isInstanceOf<ExpressionStatement>());
|
||||
Expression expression = (statement as ExpressionStatement).expression;
|
||||
expect(expression, new isInstanceOf<RethrowExpression>());
|
||||
return expression;
|
||||
}
|
||||
|
||||
@override
|
||||
BinaryExpression parseShiftExpression(String code) {
|
||||
return parseExpression(code);
|
||||
}
|
||||
|
||||
@override
|
||||
SimpleIdentifier parseSimpleIdentifier(String code) {
|
||||
return parseExpression(code);
|
||||
}
|
||||
|
||||
@override
|
||||
Statement parseStatement(String source,
|
||||
{bool enableLazyAssignmentOperators,
|
||||
int expectedEndOffset,
|
||||
bool inCatchBlock: true}) {
|
||||
// TODO(brianwilkerson) Check error codes.
|
||||
return _parse(source, (parser, token) => parser.parseStatement(token),
|
||||
inCatchBlock: inCatchBlock);
|
||||
}
|
||||
|
||||
@override
|
||||
Expression parseStringLiteral(String code) {
|
||||
return parseExpression(code);
|
||||
}
|
||||
|
||||
@override
|
||||
SymbolLiteral parseSymbolLiteral(String code) {
|
||||
return parseExpression(code);
|
||||
}
|
||||
|
||||
@override
|
||||
Expression parseThrowExpression(String code) {
|
||||
return parseExpression(code);
|
||||
}
|
||||
|
||||
@override
|
||||
Expression parseThrowExpressionWithoutCascade(String code) {
|
||||
return parseExpression(code);
|
||||
}
|
||||
|
||||
@override
|
||||
PrefixExpression parseUnaryExpression(String code) {
|
||||
return parseExpression(code);
|
||||
}
|
||||
|
||||
@override
|
||||
VariableDeclarationList parseVariableDeclarationList(String source) {
|
||||
CompilationUnit unit = parseCompilationUnit('''
|
||||
f() {
|
||||
$source;
|
||||
}
|
||||
''');
|
||||
FunctionDeclaration function = unit.declarations[0];
|
||||
BlockFunctionBody body = function.functionExpression.body;
|
||||
VariableDeclarationStatement statement = body.block.statements[0];
|
||||
return statement.variables;
|
||||
}
|
||||
|
||||
T _parse<T>(
|
||||
String source, void parseFunction(Parser parser, Token previousToken),
|
||||
{bool inAsync: false, bool inCatchBlock: false}) {
|
||||
ScannerResult scan = scanString(source);
|
||||
|
||||
CompilerTestContext c = CompilerTestContext.current;
|
||||
KernelLibraryBuilder library = new KernelLibraryBuilder(
|
||||
c.entryPoint,
|
||||
c.entryPoint,
|
||||
c.kernelTarget.loader,
|
||||
null /* actualOrigin */,
|
||||
null /* enclosingLibrary */,
|
||||
);
|
||||
List<KernelTypeVariableBuilder> typeVariableBuilders =
|
||||
<KernelTypeVariableBuilder>[];
|
||||
List<KernelFormalParameterBuilder> formalParameterBuilders =
|
||||
<KernelFormalParameterBuilder>[];
|
||||
KernelProcedureBuilder procedureBuilder = new KernelProcedureBuilder(
|
||||
null /* metadata */,
|
||||
Modifier.staticMask /* or Modifier.varMask */,
|
||||
c.kernelTarget.dynamicType,
|
||||
"analyzerTest",
|
||||
typeVariableBuilders,
|
||||
formalParameterBuilders,
|
||||
kernel.ProcedureKind.Method,
|
||||
library,
|
||||
-1 /* startCharOffset */,
|
||||
-1 /* charOffset */,
|
||||
-1 /* charOpenParenOffset */,
|
||||
-1 /* charEndOffset */);
|
||||
|
||||
TypeInferrerDisabled typeInferrer =
|
||||
new TypeInferrerDisabled(new TypeSchemaEnvironment(
|
||||
c.kernelTarget.loader.coreTypes,
|
||||
c.kernelTarget.loader.hierarchy,
|
||||
// TODO(danrubel): Enable strong mode.
|
||||
false /* strong mode */,
|
||||
));
|
||||
|
||||
AstBodyBuilder builder = new AstBodyBuilder(
|
||||
library,
|
||||
procedureBuilder,
|
||||
new UnlinkedScope(),
|
||||
null,
|
||||
c.kernelTarget.loader.hierarchy,
|
||||
c.kernelTarget.loader.coreTypes,
|
||||
null /* classBuilder */,
|
||||
false /* isInstanceMember */,
|
||||
null /* uri */,
|
||||
typeInferrer,
|
||||
typeProvider,
|
||||
)..constantContext = ConstantContext.none; // .inferred ?
|
||||
|
||||
Parser parser = new Parser(builder);
|
||||
if (inAsync) {
|
||||
parser.asyncState = AsyncModifier.Async;
|
||||
}
|
||||
if (inCatchBlock) {
|
||||
builder.inCatchBlock = inCatchBlock;
|
||||
}
|
||||
parseFunction(parser, parser.syntheticPreviousToken(scan.tokens));
|
||||
// TODO(brianwilkerson) Check `expectedEndOffset` if it is not `null`.
|
||||
return builder.pop();
|
||||
}
|
||||
}
|
||||
|
||||
/// A parser that can be used by [FastaBodyBuilderTestCase] to support the tests
|
||||
/// that still call methods on the parser directly.
|
||||
class ParserProxy implements analyzer.Parser {
|
||||
final FastaBodyBuilderTestCase testCase;
|
||||
|
||||
ParserProxy(this.testCase);
|
||||
|
||||
@override
|
||||
noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
|
||||
|
||||
@override
|
||||
Annotation parseAnnotation() {
|
||||
CompilationUnit unit =
|
||||
testCase.parseCompilationUnit('${testCase.content} var v;');
|
||||
expect(unit.directives, hasLength(0));
|
||||
expect(unit.declarations, hasLength(1));
|
||||
expect(
|
||||
unit.declarations[0], new isInstanceOf<TopLevelVariableDeclaration>());
|
||||
TopLevelVariableDeclaration declaration = unit.declarations[0];
|
||||
expect(declaration.metadata, hasLength(1));
|
||||
return declaration.metadata[0];
|
||||
}
|
||||
|
||||
@override
|
||||
ArgumentList parseArgumentList() {
|
||||
Expression expression = testCase.parseExpression('f${testCase.content}');
|
||||
expect(expression, new isInstanceOf<MethodInvocation>());
|
||||
MethodInvocation invocation = expression;
|
||||
return invocation.argumentList;
|
||||
}
|
||||
|
||||
@override
|
||||
ClassMember parseClassMember(String className) {
|
||||
CompilationUnit unit = testCase
|
||||
.parseCompilationUnit('class $className { ${testCase.content} }');
|
||||
expect(unit.directives, hasLength(0));
|
||||
expect(unit.declarations, hasLength(1));
|
||||
expect(unit.declarations[0], new isInstanceOf<ClassDeclaration>());
|
||||
ClassDeclaration classDeclaration = unit.declarations[0];
|
||||
expect(classDeclaration.members, hasLength(1));
|
||||
return classDeclaration.members[0];
|
||||
}
|
||||
|
||||
@override
|
||||
List<Combinator> parseCombinators() {
|
||||
CompilationUnit unit = testCase
|
||||
.parseCompilationUnit('import "file.dart" ${testCase.content};');
|
||||
expect(unit.directives, hasLength(1));
|
||||
expect(unit.declarations, hasLength(0));
|
||||
expect(unit.directives[0], new isInstanceOf<LibraryDirective>());
|
||||
ImportDirective directive = unit.directives[0];
|
||||
return directive.combinators;
|
||||
}
|
||||
|
||||
@override
|
||||
CommentReference parseCommentReference(
|
||||
String referenceSource, int sourceOffset) {
|
||||
// TODO(brianwilkerson) Implement this.
|
||||
throw new UnimplementedError();
|
||||
}
|
||||
|
||||
@override
|
||||
CompilationUnit parseCompilationUnit2() {
|
||||
return testCase.parseCompilationUnit(testCase.content);
|
||||
}
|
||||
|
||||
@override
|
||||
Configuration parseConfiguration() {
|
||||
CompilationUnit unit = testCase
|
||||
.parseCompilationUnit('import "file.dart" ${testCase.content};');
|
||||
expect(unit.directives, hasLength(1));
|
||||
expect(unit.declarations, hasLength(0));
|
||||
expect(unit.directives[0], new isInstanceOf<LibraryDirective>());
|
||||
ImportDirective directive = unit.directives[0];
|
||||
expect(directive.configurations, hasLength(1));
|
||||
return directive.configurations[0];
|
||||
}
|
||||
|
||||
@override
|
||||
DottedName parseDottedName() {
|
||||
CompilationUnit unit = testCase.parseCompilationUnit(
|
||||
'import "file.dart" if (${testCase.content}) "file2.dart";');
|
||||
expect(unit.directives, hasLength(1));
|
||||
expect(unit.declarations, hasLength(0));
|
||||
expect(unit.directives[0], new isInstanceOf<LibraryDirective>());
|
||||
ImportDirective directive = unit.directives[0];
|
||||
expect(directive.configurations, hasLength(1));
|
||||
return directive.configurations[0].name;
|
||||
}
|
||||
|
||||
@override
|
||||
ExtendsClause parseExtendsClause() {
|
||||
CompilationUnit unit =
|
||||
testCase.parseCompilationUnit('class C ${testCase.content} {}');
|
||||
expect(unit.directives, hasLength(0));
|
||||
expect(unit.declarations, hasLength(1));
|
||||
expect(unit.declarations[0], new isInstanceOf<ClassDeclaration>());
|
||||
ClassDeclaration classDeclaration = unit.declarations[0];
|
||||
return classDeclaration.extendsClause;
|
||||
}
|
||||
|
||||
@override
|
||||
analyzer.FinalConstVarOrType parseFinalConstVarOrType(bool optional,
|
||||
{bool inFunctionType: false}) {
|
||||
// TODO(brianwilkerson) Implement this or re-write the tests.
|
||||
throw new UnimplementedError();
|
||||
}
|
||||
|
||||
@override
|
||||
FormalParameterList parseFormalParameterList({bool inFunctionType: false}) {
|
||||
CompilationUnit unit =
|
||||
testCase.parseCompilationUnit('f${testCase.content} {}');
|
||||
expect(unit.directives, hasLength(0));
|
||||
expect(unit.declarations, hasLength(1));
|
||||
expect(unit.declarations[0], new isInstanceOf<FunctionDeclaration>());
|
||||
FunctionDeclaration function = unit.declarations[0];
|
||||
return function.functionExpression.parameters;
|
||||
}
|
||||
|
||||
@override
|
||||
FunctionBody parseFunctionBody(bool mayBeEmpty,
|
||||
analyzer.ParserErrorCode emptyErrorCode, bool inExpression) {
|
||||
CompilationUnit unit =
|
||||
testCase.parseCompilationUnit('f() ${testCase.content}');
|
||||
expect(unit.directives, hasLength(0));
|
||||
expect(unit.declarations, hasLength(1));
|
||||
expect(unit.declarations[0], new isInstanceOf<FunctionDeclaration>());
|
||||
FunctionDeclaration declaration = unit.declarations[0];
|
||||
return declaration.functionExpression.body;
|
||||
}
|
||||
|
||||
@override
|
||||
ImplementsClause parseImplementsClause() {
|
||||
CompilationUnit unit =
|
||||
testCase.parseCompilationUnit('class C ${testCase.content} {}');
|
||||
expect(unit.directives, hasLength(0));
|
||||
expect(unit.declarations, hasLength(1));
|
||||
expect(unit.declarations[0], new isInstanceOf<ClassDeclaration>());
|
||||
ClassDeclaration classDeclaration = unit.declarations[0];
|
||||
return classDeclaration.implementsClause;
|
||||
}
|
||||
|
||||
@override
|
||||
analyzer.Modifiers parseModifiers() {
|
||||
// TODO(brianwilkerson) Implement this or re-write the tests (this might
|
||||
// need context to create the right kind of declaration for the modifiers).
|
||||
throw new UnimplementedError();
|
||||
}
|
||||
|
||||
@override
|
||||
Expression parseMultiplicativeExpression() {
|
||||
return testCase.parseExpression(testCase.content);
|
||||
}
|
||||
|
||||
@override
|
||||
Expression parsePrimaryExpression() {
|
||||
return testCase.parseExpression(testCase.content);
|
||||
}
|
||||
|
||||
@override
|
||||
SimpleIdentifier parseSimpleIdentifier(
|
||||
{bool allowKeyword: false, bool isDeclaration: false}) {
|
||||
return testCase.parseExpression(testCase.content);
|
||||
}
|
||||
|
||||
@override
|
||||
Statement parseStatement2() {
|
||||
return testCase.parseStatement(testCase.content);
|
||||
}
|
||||
|
||||
@override
|
||||
TypeAnnotation parseTypeAnnotation(bool inExpression) {
|
||||
if (inExpression) {
|
||||
// TODO(brianwilkerson) As far as I can see, this path is not used.
|
||||
throw new UnimplementedError();
|
||||
}
|
||||
CompilationUnit unit =
|
||||
testCase.parseCompilationUnit('${testCase.content} x;');
|
||||
expect(unit.directives, hasLength(0));
|
||||
expect(unit.declarations, hasLength(1));
|
||||
expect(
|
||||
unit.declarations[0], new isInstanceOf<TopLevelVariableDeclaration>());
|
||||
TopLevelVariableDeclaration variable = unit.declarations[0];
|
||||
return variable.variables.type;
|
||||
}
|
||||
|
||||
@override
|
||||
TypeArgumentList parseTypeArgumentList() {
|
||||
CompilationUnit unit =
|
||||
testCase.parseCompilationUnit('C${testCase.content} c;');
|
||||
expect(unit.directives, hasLength(0));
|
||||
expect(unit.declarations, hasLength(1));
|
||||
expect(
|
||||
unit.declarations[0], new isInstanceOf<TopLevelVariableDeclaration>());
|
||||
TopLevelVariableDeclaration variable = unit.declarations[0];
|
||||
return (variable.variables.type as TypeName).typeArguments;
|
||||
}
|
||||
|
||||
@override
|
||||
TypeName parseTypeName(bool inExpression) {
|
||||
return parseTypeAnnotation(inExpression) as TypeName;
|
||||
}
|
||||
|
||||
@override
|
||||
TypeParameter parseTypeParameter() {
|
||||
CompilationUnit unit =
|
||||
testCase.parseCompilationUnit('class C<${testCase.content}> {}');
|
||||
expect(unit.directives, hasLength(0));
|
||||
expect(unit.declarations, hasLength(1));
|
||||
expect(unit.declarations[0], new isInstanceOf<ClassDeclaration>());
|
||||
ClassDeclaration classDeclaration = unit.declarations[0];
|
||||
return classDeclaration.typeParameters.typeParameters[0];
|
||||
}
|
||||
|
||||
@override
|
||||
Expression parseUnaryExpression() {
|
||||
return testCase.parseExpression(testCase.content);
|
||||
}
|
||||
|
||||
@override
|
||||
WithClause parseWithClause() {
|
||||
CompilationUnit unit =
|
||||
testCase.parseCompilationUnit('class C ${testCase.content} {}');
|
||||
expect(unit.directives, hasLength(0));
|
||||
expect(unit.declarations, hasLength(1));
|
||||
expect(unit.declarations[0], new isInstanceOf<ClassDeclaration>());
|
||||
ClassDeclaration classDeclaration = unit.declarations[0];
|
||||
return classDeclaration.withClause;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,101 +0,0 @@
|
|||
// Copyright (c) 2018, 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.
|
||||
|
||||
import 'package:analyzer/dart/ast/ast.dart';
|
||||
import 'package:analyzer/dart/element/type.dart';
|
||||
import 'package:test/test.dart';
|
||||
import 'package:test_reflective_loader/test_reflective_loader.dart';
|
||||
|
||||
import '../../generated/parser_test.dart';
|
||||
import 'body_builder_test_helper.dart';
|
||||
|
||||
main() {
|
||||
return CompilerTestContext.runWithTestOptions((_) {
|
||||
defineReflectiveSuite(() {
|
||||
defineReflectiveTests(ResolutionTest);
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests of the fasta parser based on [ExpressionParserTestMixin].
|
||||
*/
|
||||
@reflectiveTest
|
||||
class ResolutionTest extends FastaBodyBuilderTestCase {
|
||||
ResolutionTest() : super(true);
|
||||
|
||||
test_booleanLiteral_false() {
|
||||
Expression result = parseExpression('false');
|
||||
expect(result, new isInstanceOf<BooleanLiteral>());
|
||||
expect((result as BooleanLiteral).staticType, typeProvider.boolType);
|
||||
}
|
||||
|
||||
test_booleanLiteral_true() {
|
||||
Expression result = parseExpression('true');
|
||||
expect(result, new isInstanceOf<BooleanLiteral>());
|
||||
expect((result as BooleanLiteral).staticType, typeProvider.boolType);
|
||||
}
|
||||
|
||||
test_doubleLiteral() {
|
||||
Expression result = parseExpression('4.2');
|
||||
expect(result, new isInstanceOf<DoubleLiteral>());
|
||||
expect((result as DoubleLiteral).staticType, typeProvider.doubleType);
|
||||
}
|
||||
|
||||
test_integerLiteral() {
|
||||
Expression result = parseExpression('3');
|
||||
expect(result, new isInstanceOf<IntegerLiteral>());
|
||||
expect((result as IntegerLiteral).staticType, typeProvider.intType);
|
||||
}
|
||||
|
||||
@failingTest
|
||||
test_listLiteral_explicitType() {
|
||||
Expression result = parseExpression('<int>[]');
|
||||
expect(result, new isInstanceOf<ListLiteral>());
|
||||
InterfaceType listType = typeProvider.listType;
|
||||
expect((result as ListLiteral).staticType,
|
||||
listType.instantiate([typeProvider.intType]));
|
||||
}
|
||||
|
||||
@failingTest
|
||||
test_listLiteral_noType() {
|
||||
Expression result = parseExpression('[]');
|
||||
expect(result, new isInstanceOf<ListLiteral>());
|
||||
InterfaceType listType = typeProvider.listType;
|
||||
expect((result as ListLiteral).staticType,
|
||||
listType.instantiate([typeProvider.dynamicType]));
|
||||
}
|
||||
|
||||
@failingTest
|
||||
test_mapLiteral_explicitType() {
|
||||
Expression result = parseExpression('<String, int>{}');
|
||||
expect(result, new isInstanceOf<MapLiteral>());
|
||||
InterfaceType mapType = typeProvider.mapType;
|
||||
expect((result as MapLiteral).staticType,
|
||||
mapType.instantiate([typeProvider.stringType, typeProvider.intType]));
|
||||
}
|
||||
|
||||
@failingTest
|
||||
test_mapLiteral_noType() {
|
||||
Expression result = parseExpression('{}');
|
||||
expect(result, new isInstanceOf<MapLiteral>());
|
||||
InterfaceType mapType = typeProvider.mapType;
|
||||
expect(
|
||||
(result as MapLiteral).staticType,
|
||||
mapType
|
||||
.instantiate([typeProvider.dynamicType, typeProvider.dynamicType]));
|
||||
}
|
||||
|
||||
test_nullLiteral() {
|
||||
Expression result = parseExpression('null');
|
||||
expect(result, new isInstanceOf<NullLiteral>());
|
||||
expect((result as NullLiteral).staticType, typeProvider.nullType);
|
||||
}
|
||||
|
||||
test_simpleStringLiteral() {
|
||||
Expression result = parseExpression('"abc"');
|
||||
expect(result, new isInstanceOf<SimpleStringLiteral>());
|
||||
expect((result as SimpleStringLiteral).staticType, typeProvider.stringType);
|
||||
}
|
||||
}
|
||||
|
|
@ -7,13 +7,11 @@ import 'package:test_reflective_loader/test_reflective_loader.dart';
|
|||
import 'ast_builder_test.dart' as ast_builder;
|
||||
import 'message_coverage_test.dart' as message_coverage;
|
||||
import 'recovery/test_all.dart' as recovery;
|
||||
import 'resolution_test.dart' as resolution;
|
||||
|
||||
main() {
|
||||
defineReflectiveSuite(() {
|
||||
ast_builder.main();
|
||||
message_coverage.main();
|
||||
recovery.main();
|
||||
resolution.main();
|
||||
}, name: 'fasta');
|
||||
}
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -53,8 +53,10 @@ import 'kernel_api.dart' show printQualifiedNameOn;
|
|||
|
||||
import 'kernel_ast_api.dart'
|
||||
show
|
||||
Arguments,
|
||||
DartType,
|
||||
DynamicType,
|
||||
Expression,
|
||||
Initializer,
|
||||
InvalidType,
|
||||
Member,
|
||||
|
|
@ -86,7 +88,7 @@ export 'kernel_expression_generator.dart'
|
|||
ThisAccessGenerator,
|
||||
buildIsNull;
|
||||
|
||||
abstract class ExpressionGenerator<Expression, Statement, Arguments> {
|
||||
abstract class ExpressionGenerator {
|
||||
/// Builds a [Expression] representing a read from the generator.
|
||||
Expression buildSimpleRead();
|
||||
|
||||
|
|
@ -159,15 +161,14 @@ abstract class ExpressionGenerator<Expression, Statement, Arguments> {
|
|||
/// generate an invocation of `operator[]` or `operator[]=`, so we create a
|
||||
/// [Generator] object. Later, after `= b` is parsed, [buildAssignment] will
|
||||
/// be called.
|
||||
abstract class Generator<Expression, Statement, Arguments>
|
||||
implements ExpressionGenerator<Expression, Statement, Arguments> {
|
||||
final ExpressionGeneratorHelper<Expression, Statement, Arguments> helper;
|
||||
abstract class Generator implements ExpressionGenerator {
|
||||
final ExpressionGeneratorHelper helper;
|
||||
|
||||
final Token token;
|
||||
|
||||
Generator(this.helper, this.token);
|
||||
|
||||
Forest<Expression, Statement, Token, Arguments> get forest => helper.forest;
|
||||
Forest get forest => helper.forest;
|
||||
|
||||
String get plainNameForRead;
|
||||
|
||||
|
|
@ -179,11 +180,6 @@ abstract class Generator<Expression, Statement, Arguments>
|
|||
|
||||
bool get isInitializer => false;
|
||||
|
||||
// TODO(ahe): Remove this method.
|
||||
T storeOffset<T>(T node, int offset) {
|
||||
return helper.storeOffset(node, offset);
|
||||
}
|
||||
|
||||
Expression buildForEffect() => buildSimpleRead();
|
||||
|
||||
Initializer buildFieldInitializer(Map<String, int> initializedFields) {
|
||||
|
|
@ -212,14 +208,8 @@ abstract class Generator<Expression, Statement, Arguments>
|
|||
helper.deprecated_addCompileTimeError(
|
||||
offsetForToken(token), "Not a constant expression.");
|
||||
}
|
||||
return PropertyAccessGenerator.make<Expression, Statement, Arguments>(
|
||||
helper,
|
||||
send.token,
|
||||
buildSimpleRead(),
|
||||
send.name,
|
||||
null,
|
||||
null,
|
||||
isNullAware);
|
||||
return PropertyAccessGenerator.make(helper, send.token, buildSimpleRead(),
|
||||
send.name, null, null, isNullAware);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -264,11 +254,8 @@ abstract class Generator<Expression, Statement, Arguments>
|
|||
}
|
||||
}
|
||||
|
||||
abstract class VariableUseGenerator<Expression, Statement, Arguments>
|
||||
implements Generator<Expression, Statement, Arguments> {
|
||||
factory VariableUseGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token,
|
||||
abstract class VariableUseGenerator implements Generator {
|
||||
factory VariableUseGenerator(ExpressionGeneratorHelper helper, Token token,
|
||||
VariableDeclaration variable,
|
||||
[DartType promotedType]) {
|
||||
return helper.forest
|
||||
|
|
@ -279,10 +266,9 @@ abstract class VariableUseGenerator<Expression, Statement, Arguments>
|
|||
String get debugName => "VariableUseGenerator";
|
||||
}
|
||||
|
||||
abstract class PropertyAccessGenerator<Expression, Statement, Arguments>
|
||||
implements Generator<Expression, Statement, Arguments> {
|
||||
abstract class PropertyAccessGenerator implements Generator {
|
||||
factory PropertyAccessGenerator.internal(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
ExpressionGeneratorHelper helper,
|
||||
Token token,
|
||||
Expression receiver,
|
||||
Name name,
|
||||
|
|
@ -292,23 +278,21 @@ abstract class PropertyAccessGenerator<Expression, Statement, Arguments>
|
|||
.propertyAccessGenerator(helper, token, receiver, name, getter, setter);
|
||||
}
|
||||
|
||||
static Generator<Expression, Statement, Arguments>
|
||||
make<Expression, Statement, Arguments>(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token,
|
||||
Expression receiver,
|
||||
Name name,
|
||||
Member getter,
|
||||
Member setter,
|
||||
bool isNullAware) {
|
||||
static Generator make(
|
||||
ExpressionGeneratorHelper helper,
|
||||
Token token,
|
||||
Expression receiver,
|
||||
Name name,
|
||||
Member getter,
|
||||
Member setter,
|
||||
bool isNullAware) {
|
||||
if (helper.forest.isThisExpression(receiver)) {
|
||||
return unsupported("ThisExpression", offsetForToken(token), helper.uri);
|
||||
} else {
|
||||
return isNullAware
|
||||
? new NullAwarePropertyAccessGenerator<Expression, Statement,
|
||||
Arguments>(helper, token, receiver, name, getter, setter, null)
|
||||
: new PropertyAccessGenerator<Expression, Statement,
|
||||
Arguments>.internal(
|
||||
? new NullAwarePropertyAccessGenerator(
|
||||
helper, token, receiver, name, getter, setter, null)
|
||||
: new PropertyAccessGenerator.internal(
|
||||
helper, token, receiver, name, getter, setter);
|
||||
}
|
||||
}
|
||||
|
|
@ -322,14 +306,9 @@ abstract class PropertyAccessGenerator<Expression, Statement, Arguments>
|
|||
|
||||
/// Special case of [PropertyAccessGenerator] to avoid creating an indirect
|
||||
/// access to 'this'.
|
||||
abstract class ThisPropertyAccessGenerator<Expression, Statement, Arguments>
|
||||
implements Generator<Expression, Statement, Arguments> {
|
||||
factory ThisPropertyAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token,
|
||||
Name name,
|
||||
Member getter,
|
||||
Member setter) {
|
||||
abstract class ThisPropertyAccessGenerator implements Generator {
|
||||
factory ThisPropertyAccessGenerator(ExpressionGeneratorHelper helper,
|
||||
Token token, Name name, Member getter, Member setter) {
|
||||
return helper.forest
|
||||
.thisPropertyAccessGenerator(helper, token, name, getter, setter);
|
||||
}
|
||||
|
|
@ -341,10 +320,9 @@ abstract class ThisPropertyAccessGenerator<Expression, Statement, Arguments>
|
|||
bool get isThisPropertyAccess => true;
|
||||
}
|
||||
|
||||
abstract class NullAwarePropertyAccessGenerator<Expression, Statement,
|
||||
Arguments> implements Generator<Expression, Statement, Arguments> {
|
||||
abstract class NullAwarePropertyAccessGenerator implements Generator {
|
||||
factory NullAwarePropertyAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
ExpressionGeneratorHelper helper,
|
||||
Token token,
|
||||
Expression receiverExpression,
|
||||
Name name,
|
||||
|
|
@ -359,14 +337,9 @@ abstract class NullAwarePropertyAccessGenerator<Expression, Statement,
|
|||
String get debugName => "NullAwarePropertyAccessGenerator";
|
||||
}
|
||||
|
||||
abstract class SuperPropertyAccessGenerator<Expression, Statement, Arguments>
|
||||
implements Generator<Expression, Statement, Arguments> {
|
||||
factory SuperPropertyAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token,
|
||||
Name name,
|
||||
Member getter,
|
||||
Member setter) {
|
||||
abstract class SuperPropertyAccessGenerator implements Generator {
|
||||
factory SuperPropertyAccessGenerator(ExpressionGeneratorHelper helper,
|
||||
Token token, Name name, Member getter, Member setter) {
|
||||
return helper.forest
|
||||
.superPropertyAccessGenerator(helper, token, name, getter, setter);
|
||||
}
|
||||
|
|
@ -375,10 +348,9 @@ abstract class SuperPropertyAccessGenerator<Expression, Statement, Arguments>
|
|||
String get debugName => "SuperPropertyAccessGenerator";
|
||||
}
|
||||
|
||||
abstract class IndexedAccessGenerator<Expression, Statement, Arguments>
|
||||
implements Generator<Expression, Statement, Arguments> {
|
||||
abstract class IndexedAccessGenerator implements Generator {
|
||||
factory IndexedAccessGenerator.internal(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
ExpressionGeneratorHelper helper,
|
||||
Token token,
|
||||
Expression receiver,
|
||||
Expression index,
|
||||
|
|
@ -388,20 +360,19 @@ abstract class IndexedAccessGenerator<Expression, Statement, Arguments>
|
|||
.indexedAccessGenerator(helper, token, receiver, index, getter, setter);
|
||||
}
|
||||
|
||||
static Generator<Expression, Statement, Arguments>
|
||||
make<Expression, Statement, Arguments>(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token,
|
||||
Expression receiver,
|
||||
Expression index,
|
||||
Procedure getter,
|
||||
Procedure setter) {
|
||||
static Generator make(
|
||||
ExpressionGeneratorHelper helper,
|
||||
Token token,
|
||||
Expression receiver,
|
||||
Expression index,
|
||||
Procedure getter,
|
||||
Procedure setter) {
|
||||
if (helper.forest.isThisExpression(receiver)) {
|
||||
return new ThisIndexedAccessGenerator<Expression, Statement, Arguments>(
|
||||
return new ThisIndexedAccessGenerator(
|
||||
helper, token, index, getter, setter);
|
||||
} else {
|
||||
return new IndexedAccessGenerator<Expression, Statement,
|
||||
Arguments>.internal(helper, token, receiver, index, getter, setter);
|
||||
return new IndexedAccessGenerator.internal(
|
||||
helper, token, receiver, index, getter, setter);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -417,14 +388,9 @@ abstract class IndexedAccessGenerator<Expression, Statement, Arguments>
|
|||
|
||||
/// Special case of [IndexedAccessGenerator] to avoid creating an indirect
|
||||
/// access to 'this'.
|
||||
abstract class ThisIndexedAccessGenerator<Expression, Statement, Arguments>
|
||||
implements Generator<Expression, Statement, Arguments> {
|
||||
factory ThisIndexedAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token,
|
||||
Expression index,
|
||||
Procedure getter,
|
||||
Procedure setter) {
|
||||
abstract class ThisIndexedAccessGenerator implements Generator {
|
||||
factory ThisIndexedAccessGenerator(ExpressionGeneratorHelper helper,
|
||||
Token token, Expression index, Procedure getter, Procedure setter) {
|
||||
return helper.forest
|
||||
.thisIndexedAccessGenerator(helper, token, index, getter, setter);
|
||||
}
|
||||
|
|
@ -439,14 +405,9 @@ abstract class ThisIndexedAccessGenerator<Expression, Statement, Arguments>
|
|||
String get debugName => "ThisIndexedAccessGenerator";
|
||||
}
|
||||
|
||||
abstract class SuperIndexedAccessGenerator<Expression, Statement, Arguments>
|
||||
implements Generator<Expression, Statement, Arguments> {
|
||||
factory SuperIndexedAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token,
|
||||
Expression index,
|
||||
Member getter,
|
||||
Member setter) {
|
||||
abstract class SuperIndexedAccessGenerator implements Generator {
|
||||
factory SuperIndexedAccessGenerator(ExpressionGeneratorHelper helper,
|
||||
Token token, Expression index, Member getter, Member setter) {
|
||||
return helper.forest
|
||||
.superIndexedAccessGenerator(helper, token, index, getter, setter);
|
||||
}
|
||||
|
|
@ -458,22 +419,15 @@ abstract class SuperIndexedAccessGenerator<Expression, Statement, Arguments>
|
|||
String get debugName => "SuperIndexedAccessGenerator";
|
||||
}
|
||||
|
||||
abstract class StaticAccessGenerator<Expression, Statement, Arguments>
|
||||
implements Generator<Expression, Statement, Arguments> {
|
||||
factory StaticAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token,
|
||||
Member readTarget,
|
||||
Member writeTarget) {
|
||||
abstract class StaticAccessGenerator implements Generator {
|
||||
factory StaticAccessGenerator(ExpressionGeneratorHelper helper, Token token,
|
||||
Member readTarget, Member writeTarget) {
|
||||
return helper.forest
|
||||
.staticAccessGenerator(helper, token, readTarget, writeTarget);
|
||||
}
|
||||
|
||||
factory StaticAccessGenerator.fromBuilder(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Declaration declaration,
|
||||
Token token,
|
||||
Declaration builderSetter) {
|
||||
factory StaticAccessGenerator.fromBuilder(ExpressionGeneratorHelper helper,
|
||||
Declaration declaration, Token token, Declaration builderSetter) {
|
||||
if (declaration is AccessErrorBuilder) {
|
||||
AccessErrorBuilder error = declaration;
|
||||
declaration = error.builder;
|
||||
|
|
@ -494,8 +448,7 @@ abstract class StaticAccessGenerator<Expression, Statement, Arguments>
|
|||
setter = builderSetter.target;
|
||||
}
|
||||
}
|
||||
return new StaticAccessGenerator<Expression, Statement, Arguments>(
|
||||
helper, token, getter, setter);
|
||||
return new StaticAccessGenerator(helper, token, getter, setter);
|
||||
}
|
||||
|
||||
Member get readTarget;
|
||||
|
|
@ -504,11 +457,8 @@ abstract class StaticAccessGenerator<Expression, Statement, Arguments>
|
|||
String get debugName => "StaticAccessGenerator";
|
||||
}
|
||||
|
||||
abstract class LoadLibraryGenerator<Expression, Statement, Arguments>
|
||||
implements Generator<Expression, Statement, Arguments> {
|
||||
factory LoadLibraryGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token,
|
||||
abstract class LoadLibraryGenerator implements Generator {
|
||||
factory LoadLibraryGenerator(ExpressionGeneratorHelper helper, Token token,
|
||||
LoadLibraryBuilder builder) {
|
||||
return helper.forest.loadLibraryGenerator(helper, token, builder);
|
||||
}
|
||||
|
|
@ -520,20 +470,16 @@ abstract class LoadLibraryGenerator<Expression, Statement, Arguments>
|
|||
String get debugName => "LoadLibraryGenerator";
|
||||
}
|
||||
|
||||
abstract class DeferredAccessGenerator<Expression, Statement, Arguments>
|
||||
implements Generator<Expression, Statement, Arguments> {
|
||||
factory DeferredAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token,
|
||||
PrefixBuilder builder,
|
||||
Generator<Expression, Statement, Arguments> generator) {
|
||||
abstract class DeferredAccessGenerator implements Generator {
|
||||
factory DeferredAccessGenerator(ExpressionGeneratorHelper helper, Token token,
|
||||
PrefixBuilder builder, Generator generator) {
|
||||
return helper.forest
|
||||
.deferredAccessGenerator(helper, token, builder, generator);
|
||||
}
|
||||
|
||||
PrefixBuilder get builder;
|
||||
|
||||
Generator<Expression, Statement, Arguments> get generator;
|
||||
Generator get generator;
|
||||
|
||||
@override
|
||||
buildPropertyAccess(
|
||||
|
|
@ -541,7 +487,7 @@ abstract class DeferredAccessGenerator<Expression, Statement, Arguments>
|
|||
var propertyAccess =
|
||||
generator.buildPropertyAccess(send, operatorOffset, isNullAware);
|
||||
if (propertyAccess is Generator) {
|
||||
return new DeferredAccessGenerator<Expression, Statement, Arguments>(
|
||||
return new DeferredAccessGenerator(
|
||||
helper, token, builder, propertyAccess);
|
||||
} else {
|
||||
Expression expression = propertyAccess;
|
||||
|
|
@ -586,10 +532,9 @@ abstract class DeferredAccessGenerator<Expression, Statement, Arguments>
|
|||
}
|
||||
}
|
||||
|
||||
abstract class TypeUseGenerator<Expression, Statement, Arguments>
|
||||
implements Generator<Expression, Statement, Arguments> {
|
||||
abstract class TypeUseGenerator implements Generator {
|
||||
factory TypeUseGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
ExpressionGeneratorHelper helper,
|
||||
Token token,
|
||||
PrefixBuilder prefix,
|
||||
int declarationReferenceOffset,
|
||||
|
|
@ -666,13 +611,9 @@ abstract class TypeUseGenerator<Expression, Statement, Arguments>
|
|||
}
|
||||
}
|
||||
|
||||
abstract class ReadOnlyAccessGenerator<Expression, Statement, Arguments>
|
||||
implements Generator<Expression, Statement, Arguments> {
|
||||
factory ReadOnlyAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token,
|
||||
Expression expression,
|
||||
String plainNameForRead) {
|
||||
abstract class ReadOnlyAccessGenerator implements Generator {
|
||||
factory ReadOnlyAccessGenerator(ExpressionGeneratorHelper helper, Token token,
|
||||
Expression expression, String plainNameForRead) {
|
||||
return helper.forest
|
||||
.readOnlyAccessGenerator(helper, token, expression, plainNameForRead);
|
||||
}
|
||||
|
|
@ -681,11 +622,9 @@ abstract class ReadOnlyAccessGenerator<Expression, Statement, Arguments>
|
|||
String get debugName => "ReadOnlyAccessGenerator";
|
||||
}
|
||||
|
||||
abstract class LargeIntAccessGenerator<Expression, Statement, Arguments>
|
||||
implements Generator<Expression, Statement, Arguments> {
|
||||
abstract class LargeIntAccessGenerator implements Generator {
|
||||
factory LargeIntAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token) {
|
||||
ExpressionGeneratorHelper helper, Token token) {
|
||||
return helper.forest.largeIntAccessGenerator(helper, token);
|
||||
}
|
||||
|
||||
|
|
@ -715,8 +654,7 @@ abstract class LargeIntAccessGenerator<Expression, Statement, Arguments>
|
|||
}
|
||||
}
|
||||
|
||||
abstract class ErroneousExpressionGenerator<Expression, Statement, Arguments>
|
||||
implements Generator<Expression, Statement, Arguments> {
|
||||
abstract class ErroneousExpressionGenerator implements Generator {
|
||||
/// Pass [arguments] that must be evaluated before throwing an error. At
|
||||
/// most one of [isGetter] and [isSetter] should be true and they're passed
|
||||
/// to [ExpressionGeneratorHelper.buildThrowNoSuchMethodError] if it is used.
|
||||
|
|
@ -785,7 +723,7 @@ abstract class ErroneousExpressionGenerator<Expression, Statement, Arguments>
|
|||
// increment node that wraps an error.
|
||||
return buildError(
|
||||
forest.arguments(
|
||||
<Expression>[storeOffset(forest.literalInt(1, null), offset)],
|
||||
<Expression>[forest.literalInt(1, null)..fileOffset = offset],
|
||||
token),
|
||||
isGetter: true);
|
||||
}
|
||||
|
|
@ -797,7 +735,7 @@ abstract class ErroneousExpressionGenerator<Expression, Statement, Arguments>
|
|||
// node that wraps an error.
|
||||
return buildError(
|
||||
forest.arguments(
|
||||
<Expression>[storeOffset(forest.literalInt(1, null), offset)],
|
||||
<Expression>[forest.literalInt(1, null)..fileOffset = offset],
|
||||
token),
|
||||
isGetter: true);
|
||||
}
|
||||
|
|
@ -825,12 +763,9 @@ abstract class ErroneousExpressionGenerator<Expression, Statement, Arguments>
|
|||
}
|
||||
}
|
||||
|
||||
abstract class UnresolvedNameGenerator<Expression, Statement, Arguments>
|
||||
implements ErroneousExpressionGenerator<Expression, Statement, Arguments> {
|
||||
abstract class UnresolvedNameGenerator implements ErroneousExpressionGenerator {
|
||||
factory UnresolvedNameGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token,
|
||||
Name name) {
|
||||
ExpressionGeneratorHelper helper, Token token, Name name) {
|
||||
return helper.forest.unresolvedNameGenerator(helper, token, name);
|
||||
}
|
||||
|
||||
|
|
@ -855,7 +790,7 @@ abstract class UnresolvedNameGenerator<Expression, Statement, Arguments>
|
|||
{bool isGetter: false, bool isSetter: false, int offset}) {
|
||||
offset ??= offsetForToken(this.token);
|
||||
return helper.throwNoSuchMethodError(
|
||||
storeOffset(forest.literalNull(null), offset),
|
||||
forest.literalNull(null)..fileOffset = offset,
|
||||
plainNameForRead,
|
||||
arguments,
|
||||
offset,
|
||||
|
|
@ -864,11 +799,8 @@ abstract class UnresolvedNameGenerator<Expression, Statement, Arguments>
|
|||
}
|
||||
}
|
||||
|
||||
abstract class UnlinkedGenerator<Expression, Statement, Arguments>
|
||||
implements Generator<Expression, Statement, Arguments> {
|
||||
factory UnlinkedGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token,
|
||||
abstract class UnlinkedGenerator implements Generator {
|
||||
factory UnlinkedGenerator(ExpressionGeneratorHelper helper, Token token,
|
||||
UnlinkedDeclaration declaration) {
|
||||
return helper.forest.unlinkedGenerator(helper, token, declaration);
|
||||
}
|
||||
|
|
@ -888,9 +820,8 @@ abstract class UnlinkedGenerator<Expression, Statement, Arguments>
|
|||
}
|
||||
}
|
||||
|
||||
abstract class ContextAwareGenerator<Expression, Statement, Arguments>
|
||||
implements Generator<Expression, Statement, Arguments> {
|
||||
Generator<Expression, Statement, Arguments> get generator;
|
||||
abstract class ContextAwareGenerator implements Generator {
|
||||
Generator get generator;
|
||||
|
||||
@override
|
||||
String get plainNameForRead {
|
||||
|
|
@ -948,14 +879,9 @@ abstract class ContextAwareGenerator<Expression, Statement, Arguments>
|
|||
}
|
||||
}
|
||||
|
||||
abstract class DelayedAssignment<Expression, Statement, Arguments>
|
||||
implements ContextAwareGenerator<Expression, Statement, Arguments> {
|
||||
factory DelayedAssignment(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token,
|
||||
Generator<Expression, Statement, Arguments> generator,
|
||||
Expression value,
|
||||
String assignmentOperator) {
|
||||
abstract class DelayedAssignment implements ContextAwareGenerator {
|
||||
factory DelayedAssignment(ExpressionGeneratorHelper helper, Token token,
|
||||
Generator generator, Expression value, String assignmentOperator) {
|
||||
return helper.forest
|
||||
.delayedAssignment(helper, token, generator, value, assignmentOperator);
|
||||
}
|
||||
|
|
@ -1038,14 +964,9 @@ abstract class DelayedAssignment<Expression, Statement, Arguments>
|
|||
}
|
||||
}
|
||||
|
||||
abstract class DelayedPostfixIncrement<Expression, Statement, Arguments>
|
||||
implements ContextAwareGenerator<Expression, Statement, Arguments> {
|
||||
factory DelayedPostfixIncrement(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token,
|
||||
Generator<Expression, Statement, Arguments> generator,
|
||||
Name binaryOperator,
|
||||
Procedure interfaceTarget) {
|
||||
abstract class DelayedPostfixIncrement implements ContextAwareGenerator {
|
||||
factory DelayedPostfixIncrement(ExpressionGeneratorHelper helper, Token token,
|
||||
Generator generator, Name binaryOperator, Procedure interfaceTarget) {
|
||||
return helper.forest.delayedPostfixIncrement(
|
||||
helper, token, generator, binaryOperator, interfaceTarget);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -26,8 +26,10 @@ import 'kernel_builder.dart' show KernelTypeBuilder, PrefixBuilder;
|
|||
|
||||
import 'kernel_ast_api.dart'
|
||||
show
|
||||
Arguments,
|
||||
Constructor,
|
||||
DartType,
|
||||
Expression,
|
||||
FunctionNode,
|
||||
FunctionType,
|
||||
Initializer,
|
||||
|
|
@ -45,8 +47,7 @@ import 'kernel_builder.dart'
|
|||
PrefixBuilder,
|
||||
TypeDeclarationBuilder;
|
||||
|
||||
abstract class ExpressionGeneratorHelper<Expression, Statement, Arguments>
|
||||
implements InferenceHelper<Expression, Statement, Arguments> {
|
||||
abstract class ExpressionGeneratorHelper implements InferenceHelper {
|
||||
LibraryBuilder get library;
|
||||
|
||||
Uri get uri;
|
||||
|
|
@ -57,7 +58,7 @@ abstract class ExpressionGeneratorHelper<Expression, Statement, Arguments>
|
|||
|
||||
ConstantContext get constantContext;
|
||||
|
||||
Forest<Expression, Statement, Token, Arguments> get forest;
|
||||
Forest get forest;
|
||||
|
||||
Constructor lookupConstructor(Name name, {bool isSuper});
|
||||
|
||||
|
|
@ -152,6 +153,4 @@ abstract class ExpressionGeneratorHelper<Expression, Statement, Arguments>
|
|||
Message warnUnresolvedMethod(Name name, int charOffset, {bool isSuper});
|
||||
|
||||
void warnTypeArgumentsMismatch(String name, int expected, int charOffset);
|
||||
|
||||
T storeOffset<T>(T node, int offset);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -119,7 +119,7 @@ import 'forest.dart'
|
|||
UnlinkedDeclaration;
|
||||
|
||||
/// A shadow tree factory.
|
||||
class Fangorn extends Forest<Expression, Statement, Token, Arguments> {
|
||||
class Fangorn extends Forest {
|
||||
const Fangorn();
|
||||
|
||||
@override
|
||||
|
|
@ -426,8 +426,7 @@ class Fangorn extends Forest<Expression, Statement, Token, Arguments> {
|
|||
}
|
||||
|
||||
@override
|
||||
Statement labeledStatement(
|
||||
LabelTarget<Statement> target, Statement statement) =>
|
||||
Statement labeledStatement(LabelTarget target, Statement statement) =>
|
||||
statement;
|
||||
|
||||
@override
|
||||
|
|
@ -616,7 +615,7 @@ class Fangorn extends Forest<Expression, Statement, Token, Arguments> {
|
|||
|
||||
@override
|
||||
KernelVariableUseGenerator variableUseGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
ExpressionGeneratorHelper helper,
|
||||
Token token,
|
||||
VariableDeclaration variable,
|
||||
DartType promotedType) {
|
||||
|
|
@ -626,7 +625,7 @@ class Fangorn extends Forest<Expression, Statement, Token, Arguments> {
|
|||
|
||||
@override
|
||||
KernelPropertyAccessGenerator propertyAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
ExpressionGeneratorHelper helper,
|
||||
Token token,
|
||||
Expression receiver,
|
||||
Name name,
|
||||
|
|
@ -638,7 +637,7 @@ class Fangorn extends Forest<Expression, Statement, Token, Arguments> {
|
|||
|
||||
@override
|
||||
KernelThisPropertyAccessGenerator thisPropertyAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
ExpressionGeneratorHelper helper,
|
||||
Token token,
|
||||
Name name,
|
||||
Member getter,
|
||||
|
|
@ -649,7 +648,7 @@ class Fangorn extends Forest<Expression, Statement, Token, Arguments> {
|
|||
|
||||
@override
|
||||
KernelNullAwarePropertyAccessGenerator nullAwarePropertyAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
ExpressionGeneratorHelper helper,
|
||||
Token token,
|
||||
Expression receiverExpression,
|
||||
Name name,
|
||||
|
|
@ -662,7 +661,7 @@ class Fangorn extends Forest<Expression, Statement, Token, Arguments> {
|
|||
|
||||
@override
|
||||
KernelSuperPropertyAccessGenerator superPropertyAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
ExpressionGeneratorHelper helper,
|
||||
Token token,
|
||||
Name name,
|
||||
Member getter,
|
||||
|
|
@ -673,7 +672,7 @@ class Fangorn extends Forest<Expression, Statement, Token, Arguments> {
|
|||
|
||||
@override
|
||||
KernelIndexedAccessGenerator indexedAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
ExpressionGeneratorHelper helper,
|
||||
Token token,
|
||||
Expression receiver,
|
||||
Expression index,
|
||||
|
|
@ -685,7 +684,7 @@ class Fangorn extends Forest<Expression, Statement, Token, Arguments> {
|
|||
|
||||
@override
|
||||
KernelThisIndexedAccessGenerator thisIndexedAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
ExpressionGeneratorHelper helper,
|
||||
Token token,
|
||||
Expression index,
|
||||
Procedure getter,
|
||||
|
|
@ -696,7 +695,7 @@ class Fangorn extends Forest<Expression, Statement, Token, Arguments> {
|
|||
|
||||
@override
|
||||
KernelSuperIndexedAccessGenerator superIndexedAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
ExpressionGeneratorHelper helper,
|
||||
Token token,
|
||||
Expression index,
|
||||
Member getter,
|
||||
|
|
@ -707,7 +706,7 @@ class Fangorn extends Forest<Expression, Statement, Token, Arguments> {
|
|||
|
||||
@override
|
||||
KernelStaticAccessGenerator staticAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
ExpressionGeneratorHelper helper,
|
||||
Token token,
|
||||
Member getter,
|
||||
Member setter) {
|
||||
|
|
@ -716,7 +715,7 @@ class Fangorn extends Forest<Expression, Statement, Token, Arguments> {
|
|||
|
||||
@override
|
||||
KernelLoadLibraryGenerator loadLibraryGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
ExpressionGeneratorHelper helper,
|
||||
Token token,
|
||||
LoadLibraryBuilder builder) {
|
||||
return new KernelLoadLibraryGenerator(helper, token, builder);
|
||||
|
|
@ -724,16 +723,16 @@ class Fangorn extends Forest<Expression, Statement, Token, Arguments> {
|
|||
|
||||
@override
|
||||
KernelDeferredAccessGenerator deferredAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
ExpressionGeneratorHelper helper,
|
||||
Token token,
|
||||
PrefixBuilder builder,
|
||||
Generator<Expression, Statement, Arguments> generator) {
|
||||
Generator generator) {
|
||||
return new KernelDeferredAccessGenerator(helper, token, builder, generator);
|
||||
}
|
||||
|
||||
@override
|
||||
KernelTypeUseGenerator typeUseGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
ExpressionGeneratorHelper helper,
|
||||
Token token,
|
||||
PrefixBuilder prefix,
|
||||
int declarationReferenceOffset,
|
||||
|
|
@ -745,7 +744,7 @@ class Fangorn extends Forest<Expression, Statement, Token, Arguments> {
|
|||
|
||||
@override
|
||||
KernelReadOnlyAccessGenerator readOnlyAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
ExpressionGeneratorHelper helper,
|
||||
Token token,
|
||||
Expression expression,
|
||||
String plainNameForRead) {
|
||||
|
|
@ -755,32 +754,27 @@ class Fangorn extends Forest<Expression, Statement, Token, Arguments> {
|
|||
|
||||
@override
|
||||
KernelLargeIntAccessGenerator largeIntAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token) {
|
||||
ExpressionGeneratorHelper helper, Token token) {
|
||||
return new KernelLargeIntAccessGenerator(helper, token);
|
||||
}
|
||||
|
||||
@override
|
||||
KernelUnresolvedNameGenerator unresolvedNameGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token,
|
||||
Name name) {
|
||||
ExpressionGeneratorHelper helper, Token token, Name name) {
|
||||
return new KernelUnresolvedNameGenerator(helper, token, name);
|
||||
}
|
||||
|
||||
@override
|
||||
KernelUnlinkedGenerator unlinkedGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token,
|
||||
UnlinkedDeclaration declaration) {
|
||||
KernelUnlinkedGenerator unlinkedGenerator(ExpressionGeneratorHelper helper,
|
||||
Token token, UnlinkedDeclaration declaration) {
|
||||
return new KernelUnlinkedGenerator(helper, token, declaration);
|
||||
}
|
||||
|
||||
@override
|
||||
KernelDelayedAssignment delayedAssignment(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
ExpressionGeneratorHelper helper,
|
||||
Token token,
|
||||
Generator<Expression, Statement, Arguments> generator,
|
||||
Generator generator,
|
||||
Expression value,
|
||||
String assignmentOperator) {
|
||||
return new KernelDelayedAssignment(
|
||||
|
|
@ -789,9 +783,9 @@ class Fangorn extends Forest<Expression, Statement, Token, Arguments> {
|
|||
|
||||
@override
|
||||
KernelDelayedPostfixIncrement delayedPostfixIncrement(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
ExpressionGeneratorHelper helper,
|
||||
Token token,
|
||||
Generator<Expression, Statement, Arguments> generator,
|
||||
Generator generator,
|
||||
Name binaryOperator,
|
||||
Procedure interfaceTarget) {
|
||||
return new KernelDelayedPostfixIncrement(
|
||||
|
|
|
|||
|
|
@ -4,13 +4,15 @@
|
|||
|
||||
library fasta.forest;
|
||||
|
||||
import 'package:kernel/ast.dart' as kernel
|
||||
import 'package:kernel/ast.dart'
|
||||
show
|
||||
Arguments, // TODO(ahe): Remove this import.
|
||||
DartType,
|
||||
Expression,
|
||||
Member,
|
||||
Name,
|
||||
Procedure;
|
||||
Procedure,
|
||||
Statement;
|
||||
|
||||
import 'body_builder.dart' show Identifier, LabelTarget;
|
||||
|
||||
|
|
@ -25,6 +27,8 @@ import 'kernel_builder.dart'
|
|||
TypeDeclarationBuilder,
|
||||
UnlinkedDeclaration;
|
||||
|
||||
import '../scanner.dart' show Token;
|
||||
|
||||
export 'body_builder.dart' show Identifier, Operator;
|
||||
|
||||
export 'expression_generator.dart' show Generator;
|
||||
|
|
@ -39,15 +43,13 @@ export 'kernel_builder.dart'
|
|||
UnlinkedDeclaration;
|
||||
|
||||
/// A tree factory.
|
||||
///
|
||||
/// For now, the [Location] is always a token.
|
||||
abstract class Forest<Expression, Statement, Location, Arguments> {
|
||||
abstract class Forest {
|
||||
const Forest();
|
||||
|
||||
Arguments arguments(List<Expression> positional, Location location,
|
||||
Arguments arguments(List<Expression> positional, Token location,
|
||||
{covariant List types, covariant List named});
|
||||
|
||||
Arguments argumentsEmpty(Location location);
|
||||
Arguments argumentsEmpty(Token location);
|
||||
|
||||
List argumentsNamed(Arguments arguments);
|
||||
|
||||
|
|
@ -61,15 +63,15 @@ abstract class Forest<Expression, Statement, Location, Arguments> {
|
|||
|
||||
/// Return a representation of a boolean literal at the given [location]. The
|
||||
/// literal has the given [value].
|
||||
Expression literalBool(bool value, Location location);
|
||||
Expression literalBool(bool value, Token location);
|
||||
|
||||
/// Return a representation of a double literal at the given [location]. The
|
||||
/// literal has the given [value].
|
||||
Expression literalDouble(double value, Location location);
|
||||
Expression literalDouble(double value, Token location);
|
||||
|
||||
/// Return a representation of an integer literal at the given [location]. The
|
||||
/// literal has the given [value].
|
||||
Expression literalInt(int value, Location location);
|
||||
Expression literalInt(int value, Token location);
|
||||
|
||||
/// Return a representation of a list literal. The [constKeyword] is the
|
||||
/// location of the `const` keyword, or `null` if there is no keyword. The
|
||||
|
|
@ -83,13 +85,13 @@ abstract class Forest<Expression, Statement, Location, Arguments> {
|
|||
/// [expressions] is a list of the representations of the list elements. The
|
||||
/// [rightBracket] is the location of the `]`.
|
||||
Expression literalList(
|
||||
Location constKeyword,
|
||||
Token constKeyword,
|
||||
bool isConst,
|
||||
Object typeArgument,
|
||||
Object typeArguments,
|
||||
Location leftBracket,
|
||||
Token leftBracket,
|
||||
List<Expression> expressions,
|
||||
Location rightBracket);
|
||||
Token rightBracket);
|
||||
|
||||
/// Return a representation of a map literal. The [constKeyword] is the
|
||||
/// location of the `const` keyword, or `null` if there is no keyword. The
|
||||
|
|
@ -105,41 +107,40 @@ abstract class Forest<Expression, Statement, Location, Arguments> {
|
|||
/// of the `{`. The list of [entries] is a list of the representations of the
|
||||
/// map entries. The [rightBracket] is the location of the `}`.
|
||||
Expression literalMap(
|
||||
Location constKeyword,
|
||||
Token constKeyword,
|
||||
bool isConst,
|
||||
covariant keyType,
|
||||
covariant valueType,
|
||||
Object typeArguments,
|
||||
Location leftBracket,
|
||||
Token leftBracket,
|
||||
covariant List entries,
|
||||
Location rightBracket);
|
||||
Token rightBracket);
|
||||
|
||||
/// Return a representation of a null literal at the given [location].
|
||||
Expression literalNull(Location location);
|
||||
Expression literalNull(Token location);
|
||||
|
||||
/// Return a representation of a simple string literal at the given
|
||||
/// [location]. The literal has the given [value]. This does not include
|
||||
/// either adjacent strings or interpolated strings.
|
||||
Expression literalString(String value, Location location);
|
||||
Expression literalString(String value, Token location);
|
||||
|
||||
/// Return a representation of a symbol literal defined by the [hash] and the
|
||||
/// list of [components]. The [value] is the string value of the symbol.
|
||||
Expression literalSymbolMultiple(
|
||||
String value, Location hash, List<Identifier> components);
|
||||
String value, Token hash, List<Identifier> components);
|
||||
|
||||
/// Return a representation of a symbol literal defined by the [hash] and the
|
||||
/// single [component]. The component can be either an [Identifier] or an
|
||||
/// [Operator]. The [value] is the string value of the symbol.
|
||||
Expression literalSymbolSingluar(
|
||||
String value, Location hash, Object component);
|
||||
Expression literalSymbolSingluar(String value, Token hash, Object component);
|
||||
|
||||
Expression literalType(covariant type, Location location);
|
||||
Expression literalType(covariant type, Token location);
|
||||
|
||||
/// Return a representation of a key/value pair in a literal map. The [key] is
|
||||
/// the representation of the expression used to compute the key. The [colon]
|
||||
/// is the location of the colon separating the key and the value. The [value]
|
||||
/// is the representation of the expression used to compute the value.
|
||||
Object mapEntry(Expression key, Location colon, Expression value);
|
||||
Object mapEntry(Expression key, Token colon, Expression value);
|
||||
|
||||
/// Return a list that can hold [length] representations of map entries, as
|
||||
/// returned from [mapEntry].
|
||||
|
|
@ -153,45 +154,40 @@ abstract class Forest<Expression, Statement, Location, Arguments> {
|
|||
|
||||
/// Given a representation of a list of [typeArguments], return the type
|
||||
/// associated with the argument at the given [index].
|
||||
kernel.DartType getTypeAt(covariant typeArguments, int index);
|
||||
DartType getTypeAt(covariant typeArguments, int index);
|
||||
|
||||
Expression loadLibrary(covariant dependency);
|
||||
|
||||
Expression checkLibraryIsLoaded(covariant dependency);
|
||||
|
||||
Expression asExpression(
|
||||
Expression expression, covariant type, Location location);
|
||||
Expression expression, covariant type, Token location);
|
||||
|
||||
/// Return a representation of an assert that appears in a constructor's
|
||||
/// initializer list.
|
||||
Object assertInitializer(Location assertKeyword, Location leftParenthesis,
|
||||
Expression condition, Location comma, Expression message);
|
||||
Object assertInitializer(Token assertKeyword, Token leftParenthesis,
|
||||
Expression condition, Token comma, Expression message);
|
||||
|
||||
/// Return a representation of an assert that appears as a statement.
|
||||
Statement assertStatement(
|
||||
Location assertKeyword,
|
||||
Location leftParenthesis,
|
||||
Expression condition,
|
||||
Location comma,
|
||||
Expression message,
|
||||
Location semicolon);
|
||||
Statement assertStatement(Token assertKeyword, Token leftParenthesis,
|
||||
Expression condition, Token comma, Expression message, Token semicolon);
|
||||
|
||||
Expression awaitExpression(Expression operand, Location location);
|
||||
Expression awaitExpression(Expression operand, Token location);
|
||||
|
||||
/// Return a representation of a block of [statements] enclosed between the
|
||||
/// [openBracket] and [closeBracket].
|
||||
Statement block(
|
||||
Location openBrace, List<Statement> statements, Location closeBrace);
|
||||
Token openBrace, List<Statement> statements, Token closeBrace);
|
||||
|
||||
/// Return a representation of a break statement.
|
||||
Statement breakStatement(
|
||||
Location breakKeyword, Identifier label, Location semicolon);
|
||||
Token breakKeyword, Identifier label, Token semicolon);
|
||||
|
||||
/// Return a representation of a catch clause.
|
||||
Object catchClause(
|
||||
Location onKeyword,
|
||||
Token onKeyword,
|
||||
covariant exceptionType,
|
||||
Location catchKeyword,
|
||||
Token catchKeyword,
|
||||
covariant exceptionParameter,
|
||||
covariant stackTraceParameter,
|
||||
covariant stackTraceType,
|
||||
|
|
@ -202,95 +198,90 @@ abstract class Forest<Expression, Statement, Location, Arguments> {
|
|||
/// [thenExpression] is the expression following the question mark. The
|
||||
/// [colon] is the `:`. The [elseExpression] is the expression following the
|
||||
/// colon.
|
||||
Expression conditionalExpression(Expression condition, Location question,
|
||||
Expression thenExpression, Location colon, Expression elseExpression);
|
||||
Expression conditionalExpression(Expression condition, Token question,
|
||||
Expression thenExpression, Token colon, Expression elseExpression);
|
||||
|
||||
/// Return a representation of a continue statement.
|
||||
Statement continueStatement(
|
||||
Location continueKeyword, Identifier label, Location semicolon);
|
||||
Token continueKeyword, Identifier label, Token semicolon);
|
||||
|
||||
/// Return a representation of a do statement.
|
||||
Statement doStatement(
|
||||
Location doKeyword,
|
||||
Statement body,
|
||||
Location whileKeyword,
|
||||
covariant Expression condition,
|
||||
Location semicolon);
|
||||
Statement doStatement(Token doKeyword, Statement body, Token whileKeyword,
|
||||
covariant Expression condition, Token semicolon);
|
||||
|
||||
/// Return a representation of an expression statement composed from the
|
||||
/// [expression] and [semicolon].
|
||||
Statement expressionStatement(Expression expression, Location semicolon);
|
||||
Statement expressionStatement(Expression expression, Token semicolon);
|
||||
|
||||
/// Return a representation of an empty statement consisting of the given
|
||||
/// [semicolon].
|
||||
Statement emptyStatement(Location semicolon);
|
||||
Statement emptyStatement(Token semicolon);
|
||||
|
||||
/// Return a representation of a for statement.
|
||||
Statement forStatement(
|
||||
Location forKeyword,
|
||||
Location leftParenthesis,
|
||||
Token forKeyword,
|
||||
Token leftParenthesis,
|
||||
covariant variableList,
|
||||
covariant initialization,
|
||||
Location leftSeparator,
|
||||
Token leftSeparator,
|
||||
Expression condition,
|
||||
Statement conditionStatement,
|
||||
List<Expression> updaters,
|
||||
Location rightParenthesis,
|
||||
Token rightParenthesis,
|
||||
Statement body);
|
||||
|
||||
/// Return a representation of an `if` statement.
|
||||
Statement ifStatement(Location ifKeyword, covariant Expression condition,
|
||||
Statement thenStatement, Location elseKeyword, Statement elseStatement);
|
||||
Statement ifStatement(Token ifKeyword, covariant Expression condition,
|
||||
Statement thenStatement, Token elseKeyword, Statement elseStatement);
|
||||
|
||||
/// Return a representation of an `is` expression. The [operand] is the
|
||||
/// representation of the left operand. The [isOperator] is the `is` operator.
|
||||
/// The [notOperator] is either the `!` or `null` if the test is not negated.
|
||||
/// The [type] is a representation of the type that is the right operand.
|
||||
Expression isExpression(Expression operand, Location isOperator,
|
||||
Location notOperator, covariant type);
|
||||
Expression isExpression(
|
||||
Expression operand, Token isOperator, Token notOperator, covariant type);
|
||||
|
||||
/// Return a representation of the label consisting of the given [identifer]
|
||||
/// followed by the given [colon].
|
||||
Object label(Location identifier, Location colon);
|
||||
Object label(Token identifier, Token colon);
|
||||
|
||||
/// Return a representation of a [statement] that has one or more labels (from
|
||||
/// the [target]) associated with it.
|
||||
Statement labeledStatement(
|
||||
LabelTarget<Statement> target, Statement statement);
|
||||
Statement labeledStatement(LabelTarget target, Statement statement);
|
||||
|
||||
/// Return a representation of a logical expression having the [leftOperand],
|
||||
/// [rightOperand] and the [operator] (either `&&` or `||`).
|
||||
Expression logicalExpression(
|
||||
Expression leftOperand, Location operator, Expression rightOperand);
|
||||
Expression leftOperand, Token operator, Expression rightOperand);
|
||||
|
||||
Expression notExpression(Expression operand, Location location);
|
||||
Expression notExpression(Expression operand, Token location);
|
||||
|
||||
/// Return a representation of a parenthesized condition consisting of the
|
||||
/// given [expression] between the [leftParenthesis] and [rightParenthesis].
|
||||
Object parenthesizedCondition(Location leftParenthesis, Expression expression,
|
||||
Location rightParenthesis);
|
||||
Object parenthesizedCondition(
|
||||
Token leftParenthesis, Expression expression, Token rightParenthesis);
|
||||
|
||||
/// Return a representation of a rethrow statement consisting of the
|
||||
/// [rethrowKeyword] followed by the [semicolon].
|
||||
Statement rethrowStatement(Location rethrowKeyword, Location semicolon);
|
||||
Statement rethrowStatement(Token rethrowKeyword, Token semicolon);
|
||||
|
||||
/// Return a representation of a return statement.
|
||||
Statement returnStatement(
|
||||
Location returnKeyword, Expression expression, Location semicolon);
|
||||
Token returnKeyword, Expression expression, Token semicolon);
|
||||
|
||||
Expression stringConcatenationExpression(
|
||||
List<Expression> expressions, Location location);
|
||||
List<Expression> expressions, Token location);
|
||||
|
||||
/// The given [statement] is being used as the target of either a break or
|
||||
/// continue statement. Return the statement that should be used as the actual
|
||||
/// target.
|
||||
Statement syntheticLabeledStatement(Statement statement);
|
||||
|
||||
Expression thisExpression(Location location);
|
||||
Expression thisExpression(Token location);
|
||||
|
||||
/// Return a representation of a throw expression consisting of the
|
||||
/// [throwKeyword].
|
||||
Expression throwExpression(Location throwKeyword, Expression expression);
|
||||
Expression throwExpression(Token throwKeyword, Expression expression);
|
||||
|
||||
/// Return a representation of a try statement. The statement is introduced by
|
||||
/// the [tryKeyword] and the given [body]. If catch clauses were included,
|
||||
|
|
@ -300,8 +291,8 @@ abstract class Forest<Expression, Statement, Location, Arguments> {
|
|||
/// was an error in some part of the try statement, then an [errorReplacement]
|
||||
/// might be provided, in which case it could be returned instead of the
|
||||
/// representation of the try statement.
|
||||
Statement tryStatement(Location tryKeyword, Statement body,
|
||||
covariant catchClauses, Location finallyKeyword, Statement finallyBlock);
|
||||
Statement tryStatement(Token tryKeyword, Statement body,
|
||||
covariant catchClauses, Token finallyKeyword, Statement finallyBlock);
|
||||
|
||||
Statement variablesDeclaration(covariant List declarations, Uri uri);
|
||||
|
||||
|
|
@ -313,13 +304,13 @@ abstract class Forest<Expression, Statement, Location, Arguments> {
|
|||
/// Return a representation of a while statement introduced by the
|
||||
/// [whileKeyword] and consisting of the given [condition] and [body].
|
||||
Statement whileStatement(
|
||||
Location whileKeyword, covariant Expression condition, Statement body);
|
||||
Token whileKeyword, covariant Expression condition, Statement body);
|
||||
|
||||
/// Return a representation of a yield statement consisting of the
|
||||
/// [yieldKeyword], [star], [expression], and [semicolon]. The [star] is null
|
||||
/// when no star was included in the source code.
|
||||
Statement yieldStatement(Location yieldKeyword, Location star,
|
||||
Expression expression, Location semicolon);
|
||||
Statement yieldStatement(
|
||||
Token yieldKeyword, Token star, Expression expression, Token semicolon);
|
||||
|
||||
/// Return the expression from the given expression [statement].
|
||||
Expression getExpressionFromExpressionStatement(Statement statement);
|
||||
|
|
@ -368,127 +359,87 @@ abstract class Forest<Expression, Statement, Location, Arguments> {
|
|||
/// Set the type of the [parameter] to the given [type].
|
||||
void setParameterType(covariant parameter, covariant type);
|
||||
|
||||
Generator<Expression, Statement, Arguments> variableUseGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Location location,
|
||||
covariant variable,
|
||||
kernel.DartType promotedType);
|
||||
Generator variableUseGenerator(ExpressionGeneratorHelper helper,
|
||||
Token location, covariant variable, DartType promotedType);
|
||||
|
||||
Generator<Expression, Statement, Arguments> propertyAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Location location,
|
||||
Generator propertyAccessGenerator(
|
||||
ExpressionGeneratorHelper helper,
|
||||
Token location,
|
||||
Expression receiver,
|
||||
kernel.Name name,
|
||||
kernel.Member getter,
|
||||
kernel.Member setter);
|
||||
Name name,
|
||||
Member getter,
|
||||
Member setter);
|
||||
|
||||
Generator<Expression, Statement, Arguments> thisPropertyAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Location location,
|
||||
kernel.Name name,
|
||||
kernel.Member getter,
|
||||
kernel.Member setter);
|
||||
Generator thisPropertyAccessGenerator(ExpressionGeneratorHelper helper,
|
||||
Token location, Name name, Member getter, Member setter);
|
||||
|
||||
Generator<Expression, Statement, Arguments> nullAwarePropertyAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Location location,
|
||||
Generator nullAwarePropertyAccessGenerator(
|
||||
ExpressionGeneratorHelper helper,
|
||||
Token location,
|
||||
Expression receiverExpression,
|
||||
kernel.Name name,
|
||||
kernel.Member getter,
|
||||
kernel.Member setter,
|
||||
kernel.DartType type);
|
||||
Name name,
|
||||
Member getter,
|
||||
Member setter,
|
||||
DartType type);
|
||||
|
||||
Generator<Expression, Statement, Arguments> superPropertyAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Location location,
|
||||
kernel.Name name,
|
||||
kernel.Member getter,
|
||||
kernel.Member setter);
|
||||
Generator superPropertyAccessGenerator(ExpressionGeneratorHelper helper,
|
||||
Token location, Name name, Member getter, Member setter);
|
||||
|
||||
Generator<Expression, Statement, Arguments> indexedAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Location location,
|
||||
Generator indexedAccessGenerator(
|
||||
ExpressionGeneratorHelper helper,
|
||||
Token location,
|
||||
Expression receiver,
|
||||
Expression index,
|
||||
kernel.Procedure getter,
|
||||
kernel.Procedure setter);
|
||||
Procedure getter,
|
||||
Procedure setter);
|
||||
|
||||
Generator<Expression, Statement, Arguments> thisIndexedAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Location location,
|
||||
Expression index,
|
||||
kernel.Procedure getter,
|
||||
kernel.Procedure setter);
|
||||
Generator thisIndexedAccessGenerator(ExpressionGeneratorHelper helper,
|
||||
Token location, Expression index, Procedure getter, Procedure setter);
|
||||
|
||||
Generator<Expression, Statement, Arguments> superIndexedAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Location location,
|
||||
Expression index,
|
||||
kernel.Member getter,
|
||||
kernel.Member setter);
|
||||
Generator superIndexedAccessGenerator(ExpressionGeneratorHelper helper,
|
||||
Token location, Expression index, Member getter, Member setter);
|
||||
|
||||
Generator<Expression, Statement, Arguments> staticAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Location location,
|
||||
kernel.Member getter,
|
||||
kernel.Member setter);
|
||||
Generator staticAccessGenerator(ExpressionGeneratorHelper helper,
|
||||
Token location, Member getter, Member setter);
|
||||
|
||||
Generator<Expression, Statement, Arguments> loadLibraryGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Location location,
|
||||
LoadLibraryBuilder builder);
|
||||
Generator loadLibraryGenerator(ExpressionGeneratorHelper helper,
|
||||
Token location, LoadLibraryBuilder builder);
|
||||
|
||||
Generator<Expression, Statement, Arguments> deferredAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Location location,
|
||||
PrefixBuilder builder,
|
||||
Generator<Expression, Statement, Arguments> generator);
|
||||
Generator deferredAccessGenerator(ExpressionGeneratorHelper helper,
|
||||
Token location, PrefixBuilder builder, Generator generator);
|
||||
|
||||
Generator<Expression, Statement, Arguments> typeUseGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Location location,
|
||||
Generator typeUseGenerator(
|
||||
ExpressionGeneratorHelper helper,
|
||||
Token location,
|
||||
PrefixBuilder prefix,
|
||||
int declarationReferenceOffset,
|
||||
TypeDeclarationBuilder declaration,
|
||||
String plainNameForRead);
|
||||
|
||||
Generator<Expression, Statement, Arguments> readOnlyAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Location location,
|
||||
Expression expression,
|
||||
String plainNameForRead);
|
||||
Generator readOnlyAccessGenerator(ExpressionGeneratorHelper helper,
|
||||
Token location, Expression expression, String plainNameForRead);
|
||||
|
||||
Generator<Expression, Statement, Arguments> largeIntAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Location location);
|
||||
Generator largeIntAccessGenerator(
|
||||
ExpressionGeneratorHelper helper, Token location);
|
||||
|
||||
Generator<Expression, Statement, Arguments> unresolvedNameGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Location location,
|
||||
kernel.Name name);
|
||||
Generator unresolvedNameGenerator(
|
||||
ExpressionGeneratorHelper helper, Token location, Name name);
|
||||
|
||||
Generator<Expression, Statement, Arguments> unlinkedGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Location location,
|
||||
Generator unlinkedGenerator(ExpressionGeneratorHelper helper, Token location,
|
||||
UnlinkedDeclaration declaration);
|
||||
|
||||
Generator<Expression, Statement, Arguments> delayedAssignment(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Location location,
|
||||
Generator<Expression, Statement, Arguments> generator,
|
||||
Expression value,
|
||||
String assignmentOperator);
|
||||
Generator delayedAssignment(ExpressionGeneratorHelper helper, Token location,
|
||||
Generator generator, Expression value, String assignmentOperator);
|
||||
|
||||
Generator<Expression, Statement, Arguments> delayedPostfixIncrement(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Location location,
|
||||
Generator<Expression, Statement, Arguments> generator,
|
||||
kernel.Name binaryOperator,
|
||||
kernel.Procedure interfaceTarget);
|
||||
Generator delayedPostfixIncrement(
|
||||
ExpressionGeneratorHelper helper,
|
||||
Token location,
|
||||
Generator generator,
|
||||
Name binaryOperator,
|
||||
Procedure interfaceTarget);
|
||||
|
||||
// TODO(ahe): Remove this method when all users are moved here.
|
||||
kernel.Arguments castArguments(Arguments arguments) {
|
||||
dynamic a = arguments;
|
||||
return a;
|
||||
Arguments castArguments(Arguments arguments) {
|
||||
return arguments;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,6 +8,7 @@ library fasta.kernel_ast_api;
|
|||
|
||||
export 'package:kernel/ast.dart'
|
||||
show
|
||||
Arguments,
|
||||
AssertStatement,
|
||||
AsyncMarker,
|
||||
Block,
|
||||
|
|
|
|||
|
|
@ -4,9 +4,7 @@
|
|||
|
||||
library fasta.kernel_body_builder;
|
||||
|
||||
import 'package:kernel/ast.dart' show Arguments, Expression, Statement;
|
||||
|
||||
import '../scanner.dart' show Token;
|
||||
import 'package:kernel/ast.dart' show Expression;
|
||||
|
||||
import '../type_inference/type_inferrer.dart' show TypeInferrer;
|
||||
|
||||
|
|
@ -21,10 +19,9 @@ import 'kernel_api.dart' show ClassHierarchy, CoreTypes;
|
|||
import 'kernel_builder.dart'
|
||||
show KernelClassBuilder, KernelLibraryBuilder, ModifierBuilder, Scope;
|
||||
|
||||
class KernelBodyBuilder extends BodyBuilder<Expression, Statement, Arguments> {
|
||||
class KernelBodyBuilder extends BodyBuilder {
|
||||
@override
|
||||
final Forest<Expression, Statement, Token, Arguments> forest =
|
||||
const Fangorn();
|
||||
final Forest forest = const Fangorn();
|
||||
|
||||
KernelBodyBuilder(
|
||||
KernelLibraryBuilder library,
|
||||
|
|
|
|||
|
|
@ -3,7 +3,7 @@
|
|||
// BSD-style license that can be found in the LICENSE file.
|
||||
|
||||
import 'package:kernel/ast.dart'
|
||||
show Arguments, Expression, InvalidExpression, Node, Statement;
|
||||
show Arguments, Expression, InvalidExpression, Node;
|
||||
|
||||
import '../../scanner/token.dart' show Token;
|
||||
|
||||
|
|
@ -109,13 +109,12 @@ import 'kernel_builder.dart'
|
|||
|
||||
part 'kernel_expression_generator_impl.dart';
|
||||
|
||||
abstract class KernelExpressionGenerator
|
||||
implements ExpressionGenerator<Expression, Statement, Arguments> {
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> get helper;
|
||||
abstract class KernelExpressionGenerator implements ExpressionGenerator {
|
||||
ExpressionGeneratorHelper get helper;
|
||||
|
||||
Token get token;
|
||||
|
||||
Forest<Expression, Statement, Token, Arguments> get forest;
|
||||
Forest get forest;
|
||||
|
||||
@override
|
||||
Expression buildSimpleRead() {
|
||||
|
|
@ -135,26 +134,24 @@ abstract class KernelExpressionGenerator
|
|||
{bool voidContext: false}) {
|
||||
var complexAssignment = startComplexAssignment(value);
|
||||
if (voidContext) {
|
||||
var nullAwareCombiner = helper.storeOffset(
|
||||
forest.conditionalExpression(
|
||||
buildIsNull(_makeRead(complexAssignment), offset, helper),
|
||||
null,
|
||||
_makeWrite(value, false, complexAssignment),
|
||||
null,
|
||||
helper.storeOffset(forest.literalNull(null), offset)),
|
||||
offset);
|
||||
var nullAwareCombiner = forest.conditionalExpression(
|
||||
buildIsNull(_makeRead(complexAssignment), offset, helper),
|
||||
null,
|
||||
_makeWrite(value, false, complexAssignment),
|
||||
null,
|
||||
forest.literalNull(null)..fileOffset = offset)
|
||||
..fileOffset = offset;
|
||||
complexAssignment?.nullAwareCombiner = nullAwareCombiner;
|
||||
return _finish(nullAwareCombiner, complexAssignment);
|
||||
}
|
||||
var tmp = new VariableDeclaration.forValue(_makeRead(complexAssignment));
|
||||
var nullAwareCombiner = helper.storeOffset(
|
||||
forest.conditionalExpression(
|
||||
buildIsNull(new VariableGet(tmp), offset, helper),
|
||||
null,
|
||||
_makeWrite(value, false, complexAssignment),
|
||||
null,
|
||||
new VariableGet(tmp)),
|
||||
offset);
|
||||
var nullAwareCombiner = forest.conditionalExpression(
|
||||
buildIsNull(new VariableGet(tmp), offset, helper),
|
||||
null,
|
||||
_makeWrite(value, false, complexAssignment),
|
||||
null,
|
||||
new VariableGet(tmp))
|
||||
..fileOffset = offset;
|
||||
complexAssignment?.nullAwareCombiner = nullAwareCombiner;
|
||||
return _finish(makeLet(tmp, nullAwareCombiner), complexAssignment);
|
||||
}
|
||||
|
|
@ -181,7 +178,7 @@ abstract class KernelExpressionGenerator
|
|||
bool voidContext: false,
|
||||
Procedure interfaceTarget}) {
|
||||
return buildCompoundAssignment(
|
||||
binaryOperator, helper.storeOffset(forest.literalInt(1, null), offset),
|
||||
binaryOperator, forest.literalInt(1, null)..fileOffset = offset,
|
||||
offset: offset,
|
||||
voidContext: voidContext,
|
||||
interfaceTarget: interfaceTarget,
|
||||
|
|
@ -197,7 +194,7 @@ abstract class KernelExpressionGenerator
|
|||
return buildPrefixIncrement(binaryOperator,
|
||||
offset: offset, voidContext: true, interfaceTarget: interfaceTarget);
|
||||
}
|
||||
var rhs = helper.storeOffset(forest.literalInt(1, null), offset);
|
||||
var rhs = forest.literalInt(1, null)..fileOffset = offset;
|
||||
var complexAssignment = startComplexAssignment(rhs);
|
||||
var value = new VariableDeclaration.forValue(_makeRead(complexAssignment));
|
||||
valueAccess() => new VariableGet(value);
|
||||
|
|
@ -255,20 +252,16 @@ abstract class KernelExpressionGenerator
|
|||
new ShadowIllegalAssignment(rhs);
|
||||
}
|
||||
|
||||
abstract class KernelGenerator = Generator<Expression, Statement, Arguments>
|
||||
with KernelExpressionGenerator;
|
||||
abstract class KernelGenerator = Generator with KernelExpressionGenerator;
|
||||
|
||||
class KernelVariableUseGenerator extends KernelGenerator
|
||||
with VariableUseGenerator<Expression, Statement, Arguments> {
|
||||
with VariableUseGenerator {
|
||||
final VariableDeclaration variable;
|
||||
|
||||
final DartType promotedType;
|
||||
|
||||
KernelVariableUseGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token,
|
||||
this.variable,
|
||||
this.promotedType)
|
||||
KernelVariableUseGenerator(ExpressionGeneratorHelper helper, Token token,
|
||||
this.variable, this.promotedType)
|
||||
: super(helper, token);
|
||||
|
||||
@override
|
||||
|
|
@ -319,7 +312,7 @@ class KernelVariableUseGenerator extends KernelGenerator
|
|||
}
|
||||
|
||||
class KernelPropertyAccessGenerator extends KernelGenerator
|
||||
with PropertyAccessGenerator<Expression, Statement, Arguments> {
|
||||
with PropertyAccessGenerator {
|
||||
final Expression receiver;
|
||||
|
||||
final Name name;
|
||||
|
|
@ -330,13 +323,8 @@ class KernelPropertyAccessGenerator extends KernelGenerator
|
|||
|
||||
VariableDeclaration _receiverVariable;
|
||||
|
||||
KernelPropertyAccessGenerator.internal(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token,
|
||||
this.receiver,
|
||||
this.name,
|
||||
this.getter,
|
||||
this.setter)
|
||||
KernelPropertyAccessGenerator.internal(ExpressionGeneratorHelper helper,
|
||||
Token token, this.receiver, this.name, this.getter, this.setter)
|
||||
: super(helper, token);
|
||||
|
||||
@override
|
||||
|
|
@ -411,19 +399,15 @@ class KernelPropertyAccessGenerator extends KernelGenerator
|
|||
}
|
||||
|
||||
class KernelThisPropertyAccessGenerator extends KernelGenerator
|
||||
with ThisPropertyAccessGenerator<Expression, Statement, Arguments> {
|
||||
with ThisPropertyAccessGenerator {
|
||||
final Name name;
|
||||
|
||||
final Member getter;
|
||||
|
||||
final Member setter;
|
||||
|
||||
KernelThisPropertyAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token,
|
||||
this.name,
|
||||
this.getter,
|
||||
this.setter)
|
||||
KernelThisPropertyAccessGenerator(ExpressionGeneratorHelper helper,
|
||||
Token token, this.name, this.getter, this.setter)
|
||||
: super(helper, token);
|
||||
|
||||
@override
|
||||
|
|
@ -487,7 +471,7 @@ class KernelThisPropertyAccessGenerator extends KernelGenerator
|
|||
}
|
||||
|
||||
class KernelNullAwarePropertyAccessGenerator extends KernelGenerator
|
||||
with NullAwarePropertyAccessGenerator<Expression, Statement, Arguments> {
|
||||
with NullAwarePropertyAccessGenerator {
|
||||
final VariableDeclaration receiver;
|
||||
|
||||
final Expression receiverExpression;
|
||||
|
|
@ -501,7 +485,7 @@ class KernelNullAwarePropertyAccessGenerator extends KernelGenerator
|
|||
final DartType type;
|
||||
|
||||
KernelNullAwarePropertyAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
ExpressionGeneratorHelper helper,
|
||||
Token token,
|
||||
this.receiverExpression,
|
||||
this.name,
|
||||
|
|
@ -537,14 +521,13 @@ class KernelNullAwarePropertyAccessGenerator extends KernelGenerator
|
|||
Expression _finish(
|
||||
Expression body, ShadowComplexAssignment complexAssignment) {
|
||||
var offset = offsetForToken(token);
|
||||
var nullAwareGuard = helper.storeOffset(
|
||||
forest.conditionalExpression(
|
||||
buildIsNull(receiverAccess(), offset, helper),
|
||||
null,
|
||||
helper.storeOffset(forest.literalNull(null), offset),
|
||||
null,
|
||||
body),
|
||||
offset);
|
||||
var nullAwareGuard = forest.conditionalExpression(
|
||||
buildIsNull(receiverAccess(), offset, helper),
|
||||
null,
|
||||
forest.literalNull(null)..fileOffset = offset,
|
||||
null,
|
||||
body)
|
||||
..fileOffset = offset;
|
||||
if (complexAssignment != null) {
|
||||
body = makeLet(receiver, nullAwareGuard);
|
||||
ShadowPropertyAssign kernelPropertyAssign = complexAssignment;
|
||||
|
|
@ -585,19 +568,15 @@ class KernelNullAwarePropertyAccessGenerator extends KernelGenerator
|
|||
}
|
||||
|
||||
class KernelSuperPropertyAccessGenerator extends KernelGenerator
|
||||
with SuperPropertyAccessGenerator<Expression, Statement, Arguments> {
|
||||
with SuperPropertyAccessGenerator {
|
||||
final Name name;
|
||||
|
||||
final Member getter;
|
||||
|
||||
final Member setter;
|
||||
|
||||
KernelSuperPropertyAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token,
|
||||
this.name,
|
||||
this.getter,
|
||||
this.setter)
|
||||
KernelSuperPropertyAccessGenerator(ExpressionGeneratorHelper helper,
|
||||
Token token, this.name, this.getter, this.setter)
|
||||
: super(helper, token);
|
||||
|
||||
@override
|
||||
|
|
@ -665,7 +644,7 @@ class KernelSuperPropertyAccessGenerator extends KernelGenerator
|
|||
}
|
||||
|
||||
class KernelIndexedAccessGenerator extends KernelGenerator
|
||||
with IndexedAccessGenerator<Expression, Statement, Arguments> {
|
||||
with IndexedAccessGenerator {
|
||||
final Expression receiver;
|
||||
|
||||
final Expression index;
|
||||
|
|
@ -678,13 +657,8 @@ class KernelIndexedAccessGenerator extends KernelGenerator
|
|||
|
||||
VariableDeclaration indexVariable;
|
||||
|
||||
KernelIndexedAccessGenerator.internal(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token,
|
||||
this.receiver,
|
||||
this.index,
|
||||
this.getter,
|
||||
this.setter)
|
||||
KernelIndexedAccessGenerator.internal(ExpressionGeneratorHelper helper,
|
||||
Token token, this.receiver, this.index, this.getter, this.setter)
|
||||
: super(helper, token);
|
||||
|
||||
Expression indexAccess() {
|
||||
|
|
@ -812,7 +786,7 @@ class KernelIndexedAccessGenerator extends KernelGenerator
|
|||
}
|
||||
|
||||
class KernelThisIndexedAccessGenerator extends KernelGenerator
|
||||
with ThisIndexedAccessGenerator<Expression, Statement, Arguments> {
|
||||
with ThisIndexedAccessGenerator {
|
||||
final Expression index;
|
||||
|
||||
final Procedure getter;
|
||||
|
|
@ -821,12 +795,8 @@ class KernelThisIndexedAccessGenerator extends KernelGenerator
|
|||
|
||||
VariableDeclaration indexVariable;
|
||||
|
||||
KernelThisIndexedAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token,
|
||||
this.index,
|
||||
this.getter,
|
||||
this.setter)
|
||||
KernelThisIndexedAccessGenerator(ExpressionGeneratorHelper helper,
|
||||
Token token, this.index, this.getter, this.setter)
|
||||
: super(helper, token);
|
||||
|
||||
Expression indexAccess() {
|
||||
|
|
@ -936,7 +906,7 @@ class KernelThisIndexedAccessGenerator extends KernelGenerator
|
|||
}
|
||||
|
||||
class KernelSuperIndexedAccessGenerator extends KernelGenerator
|
||||
with SuperIndexedAccessGenerator<Expression, Statement, Arguments> {
|
||||
with SuperIndexedAccessGenerator {
|
||||
final Expression index;
|
||||
|
||||
final Member getter;
|
||||
|
|
@ -945,12 +915,8 @@ class KernelSuperIndexedAccessGenerator extends KernelGenerator
|
|||
|
||||
VariableDeclaration indexVariable;
|
||||
|
||||
KernelSuperIndexedAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token,
|
||||
this.index,
|
||||
this.getter,
|
||||
this.setter)
|
||||
KernelSuperIndexedAccessGenerator(ExpressionGeneratorHelper helper,
|
||||
Token token, this.index, this.getter, this.setter)
|
||||
: super(helper, token);
|
||||
|
||||
Expression indexAccess() {
|
||||
|
|
@ -1076,17 +1042,14 @@ class KernelSuperIndexedAccessGenerator extends KernelGenerator
|
|||
}
|
||||
|
||||
class KernelStaticAccessGenerator extends KernelGenerator
|
||||
with StaticAccessGenerator<Expression, Statement, Arguments> {
|
||||
with StaticAccessGenerator {
|
||||
@override
|
||||
final Member readTarget;
|
||||
|
||||
final Member writeTarget;
|
||||
|
||||
KernelStaticAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token,
|
||||
this.readTarget,
|
||||
this.writeTarget)
|
||||
KernelStaticAccessGenerator(ExpressionGeneratorHelper helper, Token token,
|
||||
this.readTarget, this.writeTarget)
|
||||
: assert(readTarget != null || writeTarget != null),
|
||||
super(helper, token);
|
||||
|
||||
|
|
@ -1153,13 +1116,11 @@ class KernelStaticAccessGenerator extends KernelGenerator
|
|||
}
|
||||
|
||||
class KernelLoadLibraryGenerator extends KernelGenerator
|
||||
with LoadLibraryGenerator<Expression, Statement, Arguments> {
|
||||
with LoadLibraryGenerator {
|
||||
final LoadLibraryBuilder builder;
|
||||
|
||||
KernelLoadLibraryGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token,
|
||||
this.builder)
|
||||
ExpressionGeneratorHelper helper, Token token, this.builder)
|
||||
: super(helper, token);
|
||||
|
||||
@override
|
||||
|
|
@ -1196,18 +1157,15 @@ class KernelLoadLibraryGenerator extends KernelGenerator
|
|||
}
|
||||
|
||||
class KernelDeferredAccessGenerator extends KernelGenerator
|
||||
with DeferredAccessGenerator<Expression, Statement, Arguments> {
|
||||
with DeferredAccessGenerator {
|
||||
@override
|
||||
final PrefixBuilder builder;
|
||||
|
||||
@override
|
||||
final KernelGenerator generator;
|
||||
|
||||
KernelDeferredAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token,
|
||||
this.builder,
|
||||
this.generator)
|
||||
KernelDeferredAccessGenerator(ExpressionGeneratorHelper helper, Token token,
|
||||
this.builder, this.generator)
|
||||
: super(helper, token);
|
||||
|
||||
@override
|
||||
|
|
@ -1233,7 +1191,7 @@ class KernelDeferredAccessGenerator extends KernelGenerator
|
|||
}
|
||||
|
||||
class KernelTypeUseGenerator extends KernelReadOnlyAccessGenerator
|
||||
with TypeUseGenerator<Expression, Statement, Arguments> {
|
||||
with TypeUseGenerator {
|
||||
/// The import prefix preceding the [declaration] reference, or `null` if
|
||||
/// the reference is not prefixed.
|
||||
@override
|
||||
|
|
@ -1248,7 +1206,7 @@ class KernelTypeUseGenerator extends KernelReadOnlyAccessGenerator
|
|||
final TypeDeclarationBuilder declaration;
|
||||
|
||||
KernelTypeUseGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
ExpressionGeneratorHelper helper,
|
||||
Token token,
|
||||
this.prefix,
|
||||
this.declarationReferenceOffset,
|
||||
|
|
@ -1280,8 +1238,8 @@ class KernelTypeUseGenerator extends KernelReadOnlyAccessGenerator
|
|||
Expression makeInvalidWrite(Expression value) {
|
||||
return buildThrowNoSuchMethodError(
|
||||
forest.literalNull(token),
|
||||
storeOffset(
|
||||
forest.arguments(<Expression>[value], null), value.fileOffset),
|
||||
forest.arguments(<Expression>[value], null)
|
||||
..fileOffset = value.fileOffset,
|
||||
isSetter: true);
|
||||
}
|
||||
|
||||
|
|
@ -1320,8 +1278,8 @@ class KernelTypeUseGenerator extends KernelReadOnlyAccessGenerator
|
|||
} else if (member.isField && !member.isFinal) {
|
||||
setter = member;
|
||||
}
|
||||
generator = new StaticAccessGenerator<Expression, Statement,
|
||||
Arguments>.fromBuilder(helper, member, send.token, setter);
|
||||
generator = new StaticAccessGenerator.fromBuilder(
|
||||
helper, member, send.token, setter);
|
||||
}
|
||||
|
||||
return arguments == null
|
||||
|
|
@ -1340,7 +1298,7 @@ class KernelTypeUseGenerator extends KernelReadOnlyAccessGenerator
|
|||
}
|
||||
|
||||
class KernelReadOnlyAccessGenerator extends KernelGenerator
|
||||
with ReadOnlyAccessGenerator<Expression, Statement, Arguments> {
|
||||
with ReadOnlyAccessGenerator {
|
||||
@override
|
||||
final String plainNameForRead;
|
||||
|
||||
|
|
@ -1348,11 +1306,8 @@ class KernelReadOnlyAccessGenerator extends KernelGenerator
|
|||
|
||||
VariableDeclaration value;
|
||||
|
||||
KernelReadOnlyAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token,
|
||||
this.expression,
|
||||
this.plainNameForRead)
|
||||
KernelReadOnlyAccessGenerator(ExpressionGeneratorHelper helper, Token token,
|
||||
this.expression, this.plainNameForRead)
|
||||
: super(helper, token);
|
||||
|
||||
@override
|
||||
|
|
@ -1397,10 +1352,8 @@ class KernelReadOnlyAccessGenerator extends KernelGenerator
|
|||
}
|
||||
|
||||
class KernelLargeIntAccessGenerator extends KernelGenerator
|
||||
with LargeIntAccessGenerator<Expression, Statement, Arguments> {
|
||||
KernelLargeIntAccessGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token)
|
||||
with LargeIntAccessGenerator {
|
||||
KernelLargeIntAccessGenerator(ExpressionGeneratorHelper helper, Token token)
|
||||
: super(helper, token);
|
||||
|
||||
@override
|
||||
|
|
@ -1425,16 +1378,12 @@ class KernelLargeIntAccessGenerator extends KernelGenerator
|
|||
}
|
||||
|
||||
class KernelUnresolvedNameGenerator extends KernelGenerator
|
||||
with
|
||||
ErroneousExpressionGenerator<Expression, Statement, Arguments>,
|
||||
UnresolvedNameGenerator<Expression, Statement, Arguments> {
|
||||
with ErroneousExpressionGenerator, UnresolvedNameGenerator {
|
||||
@override
|
||||
final Name name;
|
||||
|
||||
KernelUnresolvedNameGenerator(
|
||||
ExpressionGeneratorHelper<dynamic, dynamic, dynamic> helper,
|
||||
Token token,
|
||||
this.name)
|
||||
ExpressionGeneratorHelper helper, Token token, this.name)
|
||||
: super(helper, token);
|
||||
|
||||
@override
|
||||
|
|
@ -1455,8 +1404,7 @@ class KernelUnresolvedNameGenerator extends KernelGenerator
|
|||
}
|
||||
}
|
||||
|
||||
class KernelUnlinkedGenerator extends KernelGenerator
|
||||
with UnlinkedGenerator<Expression, Statement, Arguments> {
|
||||
class KernelUnlinkedGenerator extends KernelGenerator with UnlinkedGenerator {
|
||||
@override
|
||||
final UnlinkedDeclaration declaration;
|
||||
|
||||
|
|
@ -1465,9 +1413,7 @@ class KernelUnlinkedGenerator extends KernelGenerator
|
|||
final Name name;
|
||||
|
||||
KernelUnlinkedGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token,
|
||||
this.declaration)
|
||||
ExpressionGeneratorHelper helper, Token token, this.declaration)
|
||||
: name = new Name(declaration.name, helper.library.target),
|
||||
receiver = new InvalidExpression(declaration.name)
|
||||
..fileOffset = offsetForToken(token),
|
||||
|
|
@ -1503,14 +1449,12 @@ class KernelUnlinkedGenerator extends KernelGenerator
|
|||
}
|
||||
|
||||
abstract class KernelContextAwareGenerator extends KernelGenerator
|
||||
with ContextAwareGenerator<Expression, Statement, Arguments> {
|
||||
with ContextAwareGenerator {
|
||||
@override
|
||||
final Generator<Expression, Statement, Arguments> generator;
|
||||
final Generator generator;
|
||||
|
||||
KernelContextAwareGenerator(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token,
|
||||
this.generator)
|
||||
ExpressionGeneratorHelper helper, Token token, this.generator)
|
||||
: super(helper, token);
|
||||
|
||||
@override
|
||||
|
|
@ -1526,19 +1470,15 @@ abstract class KernelContextAwareGenerator extends KernelGenerator
|
|||
}
|
||||
|
||||
class KernelDelayedAssignment extends KernelContextAwareGenerator
|
||||
with DelayedAssignment<Expression, Statement, Arguments> {
|
||||
with DelayedAssignment {
|
||||
@override
|
||||
final Expression value;
|
||||
|
||||
@override
|
||||
String assignmentOperator;
|
||||
|
||||
KernelDelayedAssignment(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token,
|
||||
Generator<Expression, Statement, Arguments> generator,
|
||||
this.value,
|
||||
this.assignmentOperator)
|
||||
KernelDelayedAssignment(ExpressionGeneratorHelper helper, Token token,
|
||||
Generator generator, this.value, this.assignmentOperator)
|
||||
: super(helper, token, generator);
|
||||
|
||||
@override
|
||||
|
|
@ -1551,19 +1491,15 @@ class KernelDelayedAssignment extends KernelContextAwareGenerator
|
|||
}
|
||||
|
||||
class KernelDelayedPostfixIncrement extends KernelContextAwareGenerator
|
||||
with DelayedPostfixIncrement<Expression, Statement, Arguments> {
|
||||
with DelayedPostfixIncrement {
|
||||
@override
|
||||
final Name binaryOperator;
|
||||
|
||||
@override
|
||||
final Procedure interfaceTarget;
|
||||
|
||||
KernelDelayedPostfixIncrement(
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Token token,
|
||||
Generator<Expression, Statement, Arguments> generator,
|
||||
this.binaryOperator,
|
||||
this.interfaceTarget)
|
||||
KernelDelayedPostfixIncrement(ExpressionGeneratorHelper helper, Token token,
|
||||
Generator generator, this.binaryOperator, this.interfaceTarget)
|
||||
: super(helper, token, generator);
|
||||
}
|
||||
|
||||
|
|
@ -1572,28 +1508,23 @@ Expression makeLet(VariableDeclaration variable, Expression body) {
|
|||
return new Let(variable, body);
|
||||
}
|
||||
|
||||
Expression makeBinary(
|
||||
Expression left,
|
||||
Name operator,
|
||||
Procedure interfaceTarget,
|
||||
Expression right,
|
||||
ExpressionGeneratorHelper<Expression, Statement, Arguments> helper,
|
||||
Expression makeBinary(Expression left, Name operator, Procedure interfaceTarget,
|
||||
Expression right, ExpressionGeneratorHelper helper,
|
||||
{int offset: TreeNode.noOffset}) {
|
||||
return new ShadowMethodInvocation(
|
||||
left,
|
||||
operator,
|
||||
helper.storeOffset(
|
||||
helper.forest.castArguments(
|
||||
helper.forest.arguments(<Expression>[right], null)),
|
||||
offset),
|
||||
helper.forest
|
||||
.castArguments(helper.forest.arguments(<Expression>[right], null))
|
||||
..fileOffset = offset,
|
||||
interfaceTarget: interfaceTarget)
|
||||
..fileOffset = offset;
|
||||
}
|
||||
|
||||
Expression buildIsNull(Expression value, int offset,
|
||||
ExpressionGeneratorHelper<dynamic, dynamic, dynamic> helper) {
|
||||
Expression buildIsNull(
|
||||
Expression value, int offset, ExpressionGeneratorHelper helper) {
|
||||
return makeBinary(value, equalsName, null,
|
||||
helper.storeOffset(helper.forest.literalNull(null), offset), helper,
|
||||
helper.forest.literalNull(null)..fileOffset = offset, helper,
|
||||
offset: offset);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -21,9 +21,7 @@ class ThisAccessGenerator extends KernelGenerator {
|
|||
final bool isSuper;
|
||||
|
||||
ThisAccessGenerator(
|
||||
ExpressionGeneratorHelper<dynamic, dynamic, dynamic> helper,
|
||||
Token token,
|
||||
this.isInitializer,
|
||||
ExpressionGeneratorHelper helper, Token token, this.isInitializer,
|
||||
{this.isSuper: false})
|
||||
: super(helper, token);
|
||||
|
||||
|
|
@ -80,11 +78,11 @@ class ThisAccessGenerator extends KernelGenerator {
|
|||
Member setter =
|
||||
helper.lookupInstanceMember(name, isSuper: isSuper, isSetter: true);
|
||||
if (isSuper) {
|
||||
return new SuperPropertyAccessGenerator<Expression, Statement,
|
||||
Arguments>(helper, send.token, name, getter, setter);
|
||||
return new SuperPropertyAccessGenerator(
|
||||
helper, send.token, name, getter, setter);
|
||||
} else {
|
||||
return new ThisPropertyAccessGenerator<Expression, Statement,
|
||||
Arguments>(helper, send.token, name, getter, setter);
|
||||
return new ThisPropertyAccessGenerator(
|
||||
helper, send.token, name, getter, setter);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -111,14 +109,12 @@ class ThisAccessGenerator extends KernelGenerator {
|
|||
constructor.function, arguments, offset, <TypeParameter>[]);
|
||||
}
|
||||
if (constructor == null || argMessage != null) {
|
||||
return helper.buildInvalidInitializer(
|
||||
buildThrowNoSuchMethodError(
|
||||
storeOffset(forest.literalNull(null), offset), arguments,
|
||||
isSuper: isSuper,
|
||||
name: name.name,
|
||||
offset: offset,
|
||||
argMessage: argMessage),
|
||||
offset);
|
||||
return helper.buildInvalidInitializer(buildThrowNoSuchMethodError(
|
||||
forest.literalNull(null)..fileOffset = offset, arguments,
|
||||
isSuper: isSuper,
|
||||
name: name.name,
|
||||
offset: offset,
|
||||
argMessage: argMessage));
|
||||
} else if (isSuper) {
|
||||
return helper.buildSuperInitializer(
|
||||
false, constructor, arguments, offset);
|
||||
|
|
@ -190,9 +186,7 @@ abstract class IncompleteSendGenerator extends KernelGenerator {
|
|||
final Name name;
|
||||
|
||||
IncompleteSendGenerator(
|
||||
ExpressionGeneratorHelper<dynamic, dynamic, dynamic> helper,
|
||||
Token token,
|
||||
this.name)
|
||||
ExpressionGeneratorHelper helper, Token token, this.name)
|
||||
: super(helper, token);
|
||||
|
||||
withReceiver(Object receiver, int operatorOffset, {bool isNullAware});
|
||||
|
|
@ -218,13 +212,11 @@ abstract class IncompleteSendGenerator extends KernelGenerator {
|
|||
}
|
||||
|
||||
class IncompleteErrorGenerator extends IncompleteSendGenerator
|
||||
with ErroneousExpressionGenerator<Expression, Statement, Arguments> {
|
||||
with ErroneousExpressionGenerator {
|
||||
final Message message;
|
||||
|
||||
IncompleteErrorGenerator(
|
||||
ExpressionGeneratorHelper<dynamic, dynamic, dynamic> helper,
|
||||
Token token,
|
||||
this.message)
|
||||
ExpressionGeneratorHelper helper, Token token, this.message)
|
||||
: super(helper, token, null);
|
||||
|
||||
String get debugName => "IncompleteErrorGenerator";
|
||||
|
|
@ -266,10 +258,7 @@ class SendAccessGenerator extends IncompleteSendGenerator {
|
|||
final Arguments arguments;
|
||||
|
||||
SendAccessGenerator(
|
||||
ExpressionGeneratorHelper<dynamic, dynamic, dynamic> helper,
|
||||
Token token,
|
||||
Name name,
|
||||
this.arguments)
|
||||
ExpressionGeneratorHelper helper, Token token, Name name, this.arguments)
|
||||
: super(helper, token, name) {
|
||||
assert(arguments != null);
|
||||
}
|
||||
|
|
@ -353,9 +342,7 @@ class SendAccessGenerator extends IncompleteSendGenerator {
|
|||
|
||||
class IncompletePropertyAccessGenerator extends IncompleteSendGenerator {
|
||||
IncompletePropertyAccessGenerator(
|
||||
ExpressionGeneratorHelper<dynamic, dynamic, dynamic> helper,
|
||||
Token token,
|
||||
Name name)
|
||||
ExpressionGeneratorHelper helper, Token token, Name name)
|
||||
: super(helper, token, name);
|
||||
|
||||
String get plainNameForRead => name.name;
|
||||
|
|
@ -386,7 +373,7 @@ class IncompletePropertyAccessGenerator extends IncompleteSendGenerator {
|
|||
isQualified: true, prefix: prefix);
|
||||
}
|
||||
|
||||
return PropertyAccessGenerator.make<Expression, Statement, Arguments>(
|
||||
return PropertyAccessGenerator.make(
|
||||
helper, token, helper.toValue(receiver), name, null, null, isNullAware);
|
||||
}
|
||||
|
||||
|
|
@ -424,9 +411,7 @@ class IncompletePropertyAccessGenerator extends IncompleteSendGenerator {
|
|||
|
||||
class ParenthesizedExpressionGenerator extends KernelReadOnlyAccessGenerator {
|
||||
ParenthesizedExpressionGenerator(
|
||||
ExpressionGeneratorHelper<dynamic, dynamic, dynamic> helper,
|
||||
Token token,
|
||||
Expression expression)
|
||||
ExpressionGeneratorHelper helper, Token token, Expression expression)
|
||||
: super(helper, token, expression, null);
|
||||
|
||||
String get debugName => "ParenthesizedExpressionGenerator";
|
||||
|
|
|
|||
|
|
@ -2,11 +2,11 @@
|
|||
// 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.
|
||||
|
||||
import 'package:kernel/ast.dart' show FunctionType;
|
||||
import 'package:kernel/ast.dart' show Arguments, Expression, FunctionType;
|
||||
|
||||
import '../fasta_codes.dart' show LocatedMessage, Message;
|
||||
|
||||
abstract class InferenceHelper<Expression, Statement, Arguments> {
|
||||
abstract class InferenceHelper {
|
||||
Expression wrapInCompileTimeError(Expression expression, Message message);
|
||||
|
||||
Expression buildCompileTimeError(Message message, int charOffset, int length,
|
||||
|
|
|
|||
|
|
@ -18,7 +18,6 @@ import 'package:kernel/ast.dart'
|
|||
Name,
|
||||
Procedure,
|
||||
ProcedureKind,
|
||||
Statement,
|
||||
StringLiteral,
|
||||
TypeParameter,
|
||||
VariableDeclaration,
|
||||
|
|
@ -80,8 +79,7 @@ import 'package:front_end/src/fasta/kernel/kernel_expression_generator.dart'
|
|||
|
||||
import 'package:front_end/src/fasta/scanner.dart' show Token, scanString;
|
||||
|
||||
void check(
|
||||
String expected, Generator<Expression, Statement, Arguments> generator) {
|
||||
void check(String expected, Generator generator) {
|
||||
Expect.stringEquals(expected, "$generator");
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue