From 2d289c2df63f690d1c001976c953fdc951dafed1 Mon Sep 17 00:00:00 2001 From: Paul Berry Date: Thu, 1 Dec 2016 10:37:22 -0800 Subject: [PATCH] Modify dev_compiler to use analyzer's new AstFactory class. The old mechanism for creating analyzer ASTs (factory constructors on the interface classes) will be going away in analyzer 0.30. R=jmesserly@google.com Review URL: https://codereview.chromium.org/2545843002 . --- .../lib/src/compiler/ast_builder.dart | 88 ++++++++++--------- .../lib/src/compiler/code_generator.dart | 17 ++-- .../lib/src/compiler/reify_coercions.dart | 4 +- 3 files changed, 58 insertions(+), 51 deletions(-) diff --git a/pkg/dev_compiler/lib/src/compiler/ast_builder.dart b/pkg/dev_compiler/lib/src/compiler/ast_builder.dart index 76d534d72f5..46c57b10e04 100644 --- a/pkg/dev_compiler/lib/src/compiler/ast_builder.dart +++ b/pkg/dev_compiler/lib/src/compiler/ast_builder.dart @@ -3,6 +3,7 @@ // BSD-style license that can be found in the LICENSE file. import 'package:analyzer/dart/ast/ast.dart'; +import 'package:analyzer/dart/ast/standard_ast_factory.dart'; import 'package:analyzer/dart/ast/token.dart'; import 'package:analyzer/src/dart/ast/token.dart'; import 'package:analyzer/src/generated/utilities_dart.dart'; @@ -102,13 +103,13 @@ class AstBuilder { static PropertyAccess propertyAccess( Expression target, SimpleIdentifier name) { var p = new Token(TokenType.PERIOD, 0); - return new PropertyAccess(target, p, name); + return astFactory.propertyAccess(target, p, name); } static MethodInvocation methodInvoke(Expression target, SimpleIdentifier name, TypeArgumentList typeArguments, NodeList args) { var p = new Token(TokenType.PERIOD, 0); - return new MethodInvocation( + return astFactory.methodInvocation( target, p, name, typeArguments, argumentList(args)); } @@ -359,8 +360,8 @@ class AstBuilder { [Expression init]) { var eqToken = init != null ? new Token(TokenType.EQ, 0) : null; var varToken = new KeywordToken(Keyword.VAR, 0); - return new VariableDeclarationList(null, null, varToken, null, - [new VariableDeclaration(name, eqToken, init)]); + return astFactory.variableDeclarationList(null, null, varToken, null, + [astFactory.variableDeclaration(name, eqToken, init)]); } static VariableDeclarationStatement variableStatement(SimpleIdentifier name, @@ -372,7 +373,7 @@ class AstBuilder { static InstanceCreationExpression instanceCreation( ConstructorName ctor, List args) { var newToken = new KeywordToken(Keyword.NEW, 0); - return new InstanceCreationExpression( + return astFactory.instanceCreationExpression( newToken, ctor, RawAstBuilder.argumentList(args)); } } @@ -383,112 +384,113 @@ class RawAstBuilder { static ConstructorName constructorName(TypeName type, [SimpleIdentifier name]) { Token period = name != null ? new Token(TokenType.PERIOD, 0) : null; - return new ConstructorName(type, period, name); + return astFactory.constructorName(type, period, name); } static SimpleIdentifier identifierFromString(String name) { StringToken token = new SyntheticStringToken(TokenType.IDENTIFIER, name, 0); - return new SimpleIdentifier(token); + return astFactory.simpleIdentifier(token); } static PrefixedIdentifier prefixedIdentifier( SimpleIdentifier pre, SimpleIdentifier id) { Token period = new Token(TokenType.PERIOD, 0); - return new PrefixedIdentifier(pre, period, id); + return astFactory.prefixedIdentifier(pre, period, id); } static TypeParameter typeParameter(SimpleIdentifier name, [TypeName bound = null]) { Token keyword = (bound == null) ? null : new KeywordToken(Keyword.EXTENDS, 0); - return new TypeParameter(null, null, name, keyword, bound); + return astFactory.typeParameter(null, null, name, keyword, bound); } static TypeParameterList typeParameterList(List params) { Token lb = new Token(TokenType.LT, 0); Token rb = new Token(TokenType.GT, 0); - return new TypeParameterList(lb, params, rb); + return astFactory.typeParameterList(lb, params, rb); } static TypeArgumentList typeArgumentList(List args) { Token lb = new Token(TokenType.LT, 0); Token rb = new Token(TokenType.GT, 0); - return new TypeArgumentList(lb, args, rb); + return astFactory.typeArgumentList(lb, args, rb); } static ArgumentList argumentList(List args) { Token lp = new BeginToken(TokenType.OPEN_PAREN, 0); Token rp = new Token(TokenType.CLOSE_PAREN, 0); - return new ArgumentList(lp, args, rp); + return astFactory.argumentList(lp, args, rp); } static TypeName typeName(Identifier id, TypeArgumentList l) { - return new TypeName(id, l); + return astFactory.typeName(id, l); } static FunctionTypeAlias functionTypeAlias(TypeName ret, SimpleIdentifier name, TypeParameterList tps, FormalParameterList fps) { Token semi = new Token(TokenType.SEMICOLON, 0); Token td = new KeywordToken(Keyword.TYPEDEF, 0); - return new FunctionTypeAlias(null, null, td, ret, name, tps, fps, semi); + return astFactory.functionTypeAlias( + null, null, td, ret, name, tps, fps, semi); } static BooleanLiteral booleanLiteral(bool b) { var k = new KeywordToken(b ? Keyword.TRUE : Keyword.FALSE, 0); - return new BooleanLiteral(k, b); + return astFactory.booleanLiteral(k, b); } static NullLiteral nullLiteral() { var n = new KeywordToken(Keyword.NULL, 0); - return new NullLiteral(n); + return astFactory.nullLiteral(n); } static IntegerLiteral integerLiteral(int i) { StringToken token = new StringToken(TokenType.INT, '$i', 0); - return new IntegerLiteral(token, i); + return astFactory.integerLiteral(token, i); } static SimpleStringLiteral simpleStringLiteral(String s) { StringToken token = new StringToken(TokenType.STRING, "\"" + s + "\"", 0); - return new SimpleStringLiteral(token, s); + return astFactory.simpleStringLiteral(token, s); } static SimpleStringLiteral tripleQuotedStringLiteral(String s) { StringToken token = new StringToken(TokenType.STRING, '"""' + s + '"""', 0); - return new SimpleStringLiteral(token, s); + return astFactory.simpleStringLiteral(token, s); } static AsExpression asExpression(Expression exp, TypeName type) { Token token = new KeywordToken(Keyword.AS, 0); - return new AsExpression(exp, token, type); + return astFactory.asExpression(exp, token, type); } static IsExpression isExpression(Expression exp, TypeName type) { Token token = new KeywordToken(Keyword.IS, 0); - return new IsExpression(exp, token, null, type); + return astFactory.isExpression(exp, token, null, type); } static ParenthesizedExpression parenthesizedExpression(Expression exp) { Token lp = new BeginToken(TokenType.OPEN_PAREN, exp.offset); Token rp = new Token(TokenType.CLOSE_PAREN, exp.end); - return new ParenthesizedExpression(lp, exp, rp); + return astFactory.parenthesizedExpression(lp, exp, rp); } static BinaryExpression binaryExpression( Expression l, Token op, Expression r) { - return new BinaryExpression(l, op, r); + return astFactory.binaryExpression(l, op, r); } static ConditionalExpression conditionalExpression( Expression cond, Expression tExp, Expression fExp) { var q = new Token(TokenType.QUESTION, 0); var c = new Token(TokenType.COLON, 0); - return new ConditionalExpression(cond, q, tExp, c, fExp); + return astFactory.conditionalExpression(cond, q, tExp, c, fExp); } static Expression functionExpressionInvocation( Expression function, ArgumentList es) { - return new FunctionExpressionInvocation(function, null, es); + return astFactory.functionExpressionInvocation(function, null, es); } static FormalParameterList formalParameterList(List params) { @@ -507,67 +509,67 @@ class RawAstBuilder { ld = new BeginToken(TokenType.OPEN_CURLY_BRACKET, 0); rd = new Token(TokenType.CLOSE_CURLY_BRACKET, 0); } - return new FormalParameterList(lp, params, ld, rd, rp); + return astFactory.formalParameterList(lp, params, ld, rd, rp); } static Block block(List statements) { Token ld = new BeginToken(TokenType.OPEN_CURLY_BRACKET, 0); Token rd = new Token(TokenType.CLOSE_CURLY_BRACKET, 0); - return new Block(ld, statements, rd); + return astFactory.block(ld, statements, rd); } static BlockFunctionBody blockFunctionBody(Block b) { - return new BlockFunctionBody(null, null, b); + return astFactory.blockFunctionBody(null, null, b); } static ExpressionFunctionBody expressionFunctionBody(Expression body, [bool decl = false]) { Token semi = (decl) ? new Token(TokenType.SEMICOLON, 0) : null; - return new ExpressionFunctionBody(null, null, body, semi); + return astFactory.expressionFunctionBody(null, null, body, semi); } static ExpressionStatement expressionStatement(Expression expression) { Token semi = new Token(TokenType.SEMICOLON, 0); - return new ExpressionStatement(expression, semi); + return astFactory.expressionStatement(expression, semi); } static FunctionDeclaration functionDeclaration( TypeName rt, SimpleIdentifier f, FunctionExpression fexp) { - return new FunctionDeclaration(null, null, null, rt, null, f, fexp); + return astFactory.functionDeclaration(null, null, null, rt, null, f, fexp); } static MethodDeclaration methodDeclaration(TypeName rt, SimpleIdentifier m, FormalParameterList fl, FunctionBody body, {bool isStatic: false}) { Token st = isStatic ? new KeywordToken(Keyword.STATIC, 0) : null; - return new MethodDeclaration( + return astFactory.methodDeclaration( null, null, null, st, rt, null, null, m, null, fl, body); } static FunctionExpression functionExpression( FormalParameterList fl, FunctionBody body) { - return new FunctionExpression(null, fl, body); + return astFactory.functionExpression(null, fl, body); } static FunctionDeclarationStatement functionDeclarationStatement( FunctionDeclaration fd) { - return new FunctionDeclarationStatement(fd); + return astFactory.functionDeclarationStatement(fd); } static Statement returnExpression([Expression e]) { Token ret = new KeywordToken(Keyword.RETURN, 0); Token semi = new Token(TokenType.SEMICOLON, 0); - return new ReturnStatement(ret, e, semi); + return astFactory.returnStatement(ret, e, semi); } static SimpleFormalParameter simpleFormalParameter( SimpleIdentifier v, TypeName t) { - return new SimpleFormalParameter(null, [], null, t, v); + return astFactory.simpleFormalParameter(null, [], null, t, v); } static FunctionTypedFormalParameter functionTypedFormalParameter( TypeName ret, SimpleIdentifier v, FormalParameterList ps) { - return new FunctionTypedFormalParameter( + return astFactory.functionTypedFormalParameter( null, [], ret, v, null, ps); } @@ -576,11 +578,13 @@ class RawAstBuilder { } static FormalParameter optionalFormalParameter(NormalFormalParameter fp) { - return new DefaultFormalParameter(fp, ParameterKind.POSITIONAL, null, null); + return astFactory.defaultFormalParameter( + fp, ParameterKind.POSITIONAL, null, null); } static FormalParameter namedFormalParameter(NormalFormalParameter fp) { - return new DefaultFormalParameter(fp, ParameterKind.NAMED, null, null); + return astFactory.defaultFormalParameter( + fp, ParameterKind.NAMED, null, null); } static NamedExpression namedParameter(SimpleIdentifier s, Expression e) { @@ -588,13 +592,13 @@ class RawAstBuilder { } static NamedExpression namedExpression(SimpleIdentifier s, Expression e) { - Label l = new Label(s, new Token(TokenType.COLON, 0)); - return new NamedExpression(l, e); + Label l = astFactory.label(s, new Token(TokenType.COLON, 0)); + return astFactory.namedExpression(l, e); } static VariableDeclarationStatement variableDeclarationStatement( VariableDeclarationList varDecl) { var semi = new Token(TokenType.SEMICOLON, 0); - return new VariableDeclarationStatement(varDecl, semi); + return astFactory.variableDeclarationStatement(varDecl, semi); } } diff --git a/pkg/dev_compiler/lib/src/compiler/code_generator.dart b/pkg/dev_compiler/lib/src/compiler/code_generator.dart index 4b39975c66c..e622041f0cf 100644 --- a/pkg/dev_compiler/lib/src/compiler/code_generator.dart +++ b/pkg/dev_compiler/lib/src/compiler/code_generator.dart @@ -8,6 +8,7 @@ import 'dart:math' show min, max; import 'package:analyzer/analyzer.dart' hide ConstantEvaluator; import 'package:analyzer/dart/ast/ast.dart'; +import 'package:analyzer/dart/ast/standard_ast_factory.dart'; import 'package:analyzer/dart/ast/token.dart' show Token, TokenType; import 'package:analyzer/dart/element/element.dart'; import 'package:analyzer/dart/element/type.dart'; @@ -1314,7 +1315,7 @@ class CodeGenerator extends GeneralizingAstVisitor jsMethods.add(new JS.Method( _propertyName('constructor'), js.call('function(...args) { return this.new.apply(this, args); }') - as JS.Fun)); + as JS.Fun)); } else if (ctors.isEmpty) { jsMethods.add(_emitImplicitConstructor(node, fields, virtualFields)); } @@ -3967,7 +3968,7 @@ class CodeGenerator extends GeneralizingAstVisitor new JS.Method( access, js.call('function() { return #; }', _visitInitializer(node)) - as JS.Fun, + as JS.Fun, isGetter: true), node, _findAccessor(element, getter: true))); @@ -4453,8 +4454,8 @@ class CodeGenerator extends GeneralizingAstVisitor // LocalVariableElementImpl, so we could repurpose to mean "temp". // * add a new property to LocalVariableElementImpl. // * create a new subtype of LocalVariableElementImpl to mark a temp. - var id = - new SimpleIdentifier(new StringToken(TokenType.IDENTIFIER, name, -1)); + var id = astFactory + .simpleIdentifier(new StringToken(TokenType.IDENTIFIER, name, -1)); variable ??= new JS.TemporaryId(name); @@ -4509,14 +4510,14 @@ class CodeGenerator extends GeneralizingAstVisitor Expression result; if (expr is IndexExpression) { IndexExpression index = expr; - result = new IndexExpression.forTarget( + result = astFactory.indexExpressionForTarget( _bindValue(scope, 'o', index.target, context: context), index.leftBracket, _bindValue(scope, 'i', index.index, context: context), index.rightBracket); } else if (expr is PropertyAccess) { PropertyAccess prop = expr; - result = new PropertyAccess( + result = astFactory.propertyAccess( _bindValue(scope, 'o', _getTarget(prop), context: context), prop.operator, prop.propertyName); @@ -4525,9 +4526,9 @@ class CodeGenerator extends GeneralizingAstVisitor if (isLibraryPrefix(ident.prefix)) { return expr; } - result = new PrefixedIdentifier( + result = astFactory.prefixedIdentifier( _bindValue(scope, 'o', ident.prefix, context: context) - as SimpleIdentifier, + as SimpleIdentifier, ident.period, ident.identifier); } else { diff --git a/pkg/dev_compiler/lib/src/compiler/reify_coercions.dart b/pkg/dev_compiler/lib/src/compiler/reify_coercions.dart index c0a9f723cda..595d540c30c 100644 --- a/pkg/dev_compiler/lib/src/compiler/reify_coercions.dart +++ b/pkg/dev_compiler/lib/src/compiler/reify_coercions.dart @@ -4,6 +4,7 @@ import 'package:analyzer/analyzer.dart' as analyzer; import 'package:analyzer/dart/ast/ast.dart'; +import 'package:analyzer/dart/ast/standard_ast_factory.dart'; import 'package:analyzer/dart/element/type.dart' show DartType; import 'package:analyzer/src/dart/ast/ast.dart' show FunctionBodyImpl; import 'package:analyzer/src/dart/ast/utilities.dart' show NodeReplacer; @@ -40,7 +41,8 @@ class CoercionReifier extends analyzer.GeneralizingAstVisitor { static Expression castExpression(Expression e, DartType toType) { // We use an empty name in the AST, because the JS code generator only cares // about the target type. It does not look at the AST name. - var typeName = new TypeName(AstBuilder.identifierFromString(''), null); + var typeName = + astFactory.typeName(AstBuilder.identifierFromString(''), null); typeName.type = toType; var cast = AstBuilder.asExpression(e, typeName); cast.staticType = toType;