some fixes for --strong warnings

lib/src/codegen/ast_builder.dart

 // Copyright (c) 2015, 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.
 
 library dev_compiler.src.codegen.ast_builder;
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:logging/logging.dart' as logger;
 
 final _log = new logger.Logger('dev_compiler.ast_builder');
 
 // Wrappers around constructors for the dart ast.  The AstBuilder class
 // provides a higher-level interface, abstracting both from the lexical
 // details and some of helper classes.  The RawAstBuilder class provides
 // a low-level wrapper class (below) abstracts from the lexical details
 // but otherwise faithfully mirrors the construction API.
 class AstBuilder {
   static SimpleIdentifier identifierFromString(String name) {
     return RawAstBuilder.identifierFromString(name);
   }
 
-  static PrefixedIdentifier prefixedIdentifier(Identifier pre, Identifier id) {
+  static PrefixedIdentifier prefixedIdentifier(
+      SimpleIdentifier pre, SimpleIdentifier id) {
     return RawAstBuilder.prefixedIdentifier(pre, id);
   }
 
-  static TypeParameter typeParameter(Identifier name, [TypeName bound = null]) {
+  static TypeParameter typeParameter(SimpleIdentifier name,
+      [TypeName bound = null]) {
     return RawAstBuilder.typeParameter(name, bound);
   }
 
   static TypeParameterList typeParameterList(List<TypeParameter> params) {
     return RawAstBuilder.typeParameterList(params);
   }
 
   static TypeArgumentList typeArgumentList(List<TypeName> args) {
     return RawAstBuilder.typeArgumentList(args);
   }
 
   static ArgumentList argumentList(List<Expression> args) {
     return RawAstBuilder.argumentList(args);
   }
 
   static TypeName typeName(Identifier id, List<TypeName> args) {
     TypeArgumentList argList = null;
     if (args != null && args.length > 0) argList = typeArgumentList(args);
     return RawAstBuilder.typeName(id, argList);
   }
 
-  static FunctionTypeAlias functionTypeAlias(TypeName ret, Identifier name,
-      List<TypeParameter> tParams, List<FormalParameter> params) {
+  static FunctionTypeAlias functionTypeAlias(TypeName ret,
+      SimpleIdentifier name, List<TypeParameter> tParams,
+      List<FormalParameter> params) {
     TypeParameterList tps =
         (tParams.length == 0) ? null : typeParameterList(tParams);
     FormalParameterList fps = formalParameterList(params);
     return RawAstBuilder.functionTypeAlias(ret, name, tps, fps);
   }
 
   static BooleanLiteral booleanLiteral(bool b) {
     return RawAstBuilder.booleanLiteral(b);
   }
 
@@ skipping 179 matching lines @@
   }
 
   static FormalParameterList formalParameterList(List<FormalParameter> params) {
     return RawAstBuilder.formalParameterList(params);
   }
 
   static Block block(List<Statement> statements) {
     return RawAstBuilder.block(statements);
   }
 
-  static MethodDeclaration blockMethodDeclaration(TypeName rt, Identifier m,
-      List<FormalParameter> params, List<Statement> statements,
-      {bool isStatic: false}) {
+  static MethodDeclaration blockMethodDeclaration(TypeName rt,
+      SimpleIdentifier m, List<FormalParameter> params,
+      List<Statement> statements, {bool isStatic: false}) {
     FormalParameterList fl = formalParameterList(params);
     Block b = block(statements);
     BlockFunctionBody body = RawAstBuilder.blockFunctionBody(b);
     return RawAstBuilder.methodDeclaration(rt, m, fl, body, isStatic: isStatic);
   }
 
-  static FunctionDeclaration blockFunctionDeclaration(TypeName rt, Identifier f,
-      List<FormalParameter> params, List<Statement> statements) {
+  static FunctionDeclaration blockFunctionDeclaration(TypeName rt,
+      SimpleIdentifier f, List<FormalParameter> params,
+      List<Statement> statements) {
     FunctionExpression fexp = blockFunction(params, statements);
     return RawAstBuilder.functionDeclaration(rt, f, fexp);
   }
 
   static FunctionExpression blockFunction(
       List<FormalParameter> params, List<Statement> statements) {
     FormalParameterList fl = formalParameterList(params);
     Block b = block(statements);
     BlockFunctionBody body = RawAstBuilder.blockFunctionBody(b);
     return RawAstBuilder.functionExpression(fl, body);
   }
 
   static FunctionExpression expressionFunction(
       List<FormalParameter> params, Expression body, [bool decl = false]) {
     FormalParameterList fl = formalParameterList(params);
     ExpressionFunctionBody b = RawAstBuilder.expressionFunctionBody(body, decl);
     return RawAstBuilder.functionExpression(fl, b);
   }
 
   static FunctionDeclarationStatement functionDeclarationStatement(
-      TypeName rType, Identifier name, FunctionExpression fe) {
+      TypeName rType, SimpleIdentifier name, FunctionExpression fe) {
     var fd = RawAstBuilder.functionDeclaration(rType, name, fe);
     return RawAstBuilder.functionDeclarationStatement(fd);
   }
 
   static Statement returnExpression([Expression e]) {
     return RawAstBuilder.returnExpression(e);
   }
 
   // let b = e1 in e2 == (\b.e2)(e1)
   static Expression letExpression(
       FormalParameter b, Expression e1, Expression e2) {
     FunctionExpression l = expressionFunction(<FormalParameter>[b], e2);
     return application(parenthesize(l), <Expression>[e1]);
   }
 
-  static SimpleFormalParameter simpleFormal(Identifier v, TypeName t) {
+  static SimpleFormalParameter simpleFormal(SimpleIdentifier v, TypeName t) {
     return RawAstBuilder.simpleFormalParameter(v, t);
   }
 
   static FunctionTypedFormalParameter functionTypedFormal(
-      TypeName ret, Identifier v, List<FormalParameter> params) {
+      TypeName ret, SimpleIdentifier v, List<FormalParameter> params) {
     FormalParameterList ps = formalParameterList(params);
     return RawAstBuilder.functionTypedFormalParameter(ret, v, ps);
   }
 
   static FormalParameter requiredFormal(NormalFormalParameter fp) {
     return RawAstBuilder.requiredFormalParameter(fp);
   }
 
   static FormalParameter optionalFormal(NormalFormalParameter fp) {
     return RawAstBuilder.optionalFormalParameter(fp);
@@ skipping 13 matching lines @@
 }
 
 // This class provides a low-level wrapper around the constructors for
 // the AST.  It mostly simply abstracts from the lexical tokens.
 class RawAstBuilder {
   static SimpleIdentifier identifierFromString(String name) {
     StringToken token = new SyntheticStringToken(TokenType.IDENTIFIER, name, 0);
     return new SimpleIdentifier(token);
   }
 
-  static PrefixedIdentifier prefixedIdentifier(Identifier pre, Identifier id) {
+  static PrefixedIdentifier prefixedIdentifier(
+      SimpleIdentifier pre, SimpleIdentifier id) {
     Token period = new Token(TokenType.PERIOD, 0);
     return new PrefixedIdentifier(pre, period, id);
   }
 
-  static TypeParameter typeParameter(Identifier name, [TypeName bound = null]) {
+  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);
   }
 
   static TypeParameterList typeParameterList(List<TypeParameter> params) {
     Token lb = new Token(TokenType.LT, 0);
     Token rb = new Token(TokenType.GT, 0);
     return new TypeParameterList(lb, params, rb);
   }
 
   static TypeArgumentList typeArgumentList(List<TypeName> args) {
     Token lb = new Token(TokenType.LT, 0);
     Token rb = new Token(TokenType.GT, 0);
     return new TypeArgumentList(lb, args, rb);
   }
 
   static ArgumentList argumentList(List<Expression> args) {
     Token lp = new BeginToken(TokenType.OPEN_PAREN, 0);
     Token rp = new Token(TokenType.CLOSE_PAREN, 0);
     return new ArgumentList(lp, args, rp);
   }
 
   static TypeName typeName(Identifier id, TypeArgumentList l) {
     return new TypeName(id, l);
   }
 
-  static FunctionTypeAlias functionTypeAlias(TypeName ret, Identifier name,
-      TypeParameterList tps, FormalParameterList fps) {
+  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);
   }
 
   static BooleanLiteral booleanLiteral(bool b) {
     var k = new KeywordToken(b ? Keyword.TRUE : Keyword.FALSE, 0);
     return new BooleanLiteral(k, b);
   }
 
@@ skipping 79 matching lines @@
     return new 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);
   }
 
   static FunctionDeclaration functionDeclaration(
-      TypeName rt, Identifier f, FunctionExpression fexp) {
+      TypeName rt, SimpleIdentifier f, FunctionExpression fexp) {
     return new FunctionDeclaration(null, null, null, rt, null, f, fexp);
   }
 
-  static MethodDeclaration methodDeclaration(
-      TypeName rt, Identifier m, FormalParameterList fl, FunctionBody body,
-      {bool isStatic: false}) {
+  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(
         null, null, null, st, rt, null, null, m, null, fl, body);
   }
 
   static FunctionExpression functionExpression(
       FormalParameterList fl, FunctionBody body) {
     return new FunctionExpression(null, fl, body);
   }
 
   static FunctionDeclarationStatement functionDeclarationStatement(
       FunctionDeclaration fd) {
     return new 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);
   }
 
-  static SimpleFormalParameter simpleFormalParameter(Identifier v, TypeName t) {
+  static SimpleFormalParameter simpleFormalParameter(
+      SimpleIdentifier v, TypeName t) {
     return new SimpleFormalParameter(null, <Annotation>[], null, t, v);
   }
 
   static FunctionTypedFormalParameter functionTypedFormalParameter(
-      TypeName ret, Identifier v, FormalParameterList ps) {
+      TypeName ret, SimpleIdentifier v, FormalParameterList ps) {
     return new FunctionTypedFormalParameter(
         null, <Annotation>[], ret, v, null, ps);
   }
 
   static FormalParameter requiredFormalParameter(NormalFormalParameter fp) {
     return fp;
   }
 
   static FormalParameter optionalFormalParameter(NormalFormalParameter fp) {
     return new DefaultFormalParameter(fp, ParameterKind.POSITIONAL, null, null);
   }
 
   static FormalParameter namedFormalParameter(NormalFormalParameter fp) {
     return new DefaultFormalParameter(fp, ParameterKind.NAMED, null, null);
   }
 
-  static NamedExpression namedParameter(Identifier s, Expression e) {
+  static NamedExpression namedParameter(SimpleIdentifier s, Expression e) {
     return namedExpression(s, e);
   }
 
-  static NamedExpression namedExpression(Identifier s, Expression e) {
+  static NamedExpression namedExpression(SimpleIdentifier s, Expression e) {
     Label l = new Label(s, new Token(TokenType.COLON, 0));
     return new NamedExpression(l, e);
   }
 }