Prepare for development branch by updating externally-used API.

pkg/analyzer/lib/src/fasta/ast_builder.dart

 // Copyright (c) 2016, 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 fasta.analyzer.ast_builder;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/dart/ast/ast_factory.dart' show AstFactory;
 import 'package:analyzer/dart/ast/standard_ast_factory.dart' as standard;
 import 'package:analyzer/dart/ast/token.dart' as analyzer show Token;
@@ skipping 398 matching lines @@
     push(ast.ifStatement(
         toAnalyzerToken(ifToken),
         toAnalyzerToken(ifToken.next),
         condition,
         toAnalyzerToken(leftParenthesis.endGroup),
         thenPart,
         toAnalyzerToken(elseToken),
         elsePart));
   }
 
-  void prepareInitializers() {
-    debugEvent("prepareInitializers");
-  }
-
   void handleNoInitializers() {
     debugEvent("NoInitializers");
     push(NullValue.ConstructorInitializerSeparator);
     push(NullValue.ConstructorInitializers);
   }
 
   void endInitializers(int count, Token beginToken, Token endToken) {
     debugEvent("Initializers");
     List<Object> initializerObjects = popList(count) ?? const [];
 
@@ skipping 101 matching lines @@
     // SimpleIdentifier into a VariableDeclaration, and then when this code was
     // reached, node would always be a VariableDeclaration.
     if (node is VariableDeclaration) {
       variable = node;
     } else if (node is SimpleIdentifier) {
       variable = ast.variableDeclaration(node, null, null);
     } else {
       internalError("unhandled identifier: ${node.runtimeType}");
     }
     push(variable);
-    scope[variable.name.name] = variable.name.staticElement =
-        new AnalyzerLocalVariableElemment(variable);
+    scope.declare(
+        variable.name.name,
+        variable.name.staticElement =
+            new AnalyzerLocalVariableElemment(variable),
+        nameToken.charOffset,
+        uri);
   }
 
   void endVariablesDeclaration(int count, Token endToken) {
     debugEvent("VariablesDeclaration");
     List<VariableDeclaration> variables = popList(count);
     TypeAnnotation type = pop();
     _Modifiers modifiers = pop();
     Token keyword = modifiers?.finalConstOrVarKeyword;
     List<Annotation> metadata = pop();
     Comment comment = pop();
@@ skipping 338 matching lines @@
       }
     }
 
     ParameterKind analyzerKind = _toAnalyzerParameterKind(kind);
     if (analyzerKind != ParameterKind.REQUIRED) {
       node = ast.defaultFormalParameter(node, analyzerKind,
           toAnalyzerToken(defaultValue?.separator), defaultValue?.value);
     }
 
     if (name != null) {
-      scope[name.name] =
-          name.staticElement = new AnalyzerParameterElement(node);
+      scope.declare(
+          name.name,
+          name.staticElement = new AnalyzerParameterElement(node),
+          name.offset,
+          uri);
     }
     push(node);
   }
 
   @override
   void endFunctionTypedFormalParameter(
       Token thisKeyword, FormalParameterType kind) {
     debugEvent("FunctionTypedFormalParameter");
 
     FormalParameterList formalParameters = pop();
@@ skipping 25 matching lines @@
           comment: comment,
           covariantKeyword: toAnalyzerToken(covariantKeyword),
           type: returnType,
           thisKeyword: toAnalyzerToken(thisKeyword),
           period: toAnalyzerToken(period),
           identifier: name,
           typeParameters: typeParameters,
           parameters: formalParameters);
     }
 
-    scope[name.name] = name.staticElement = new AnalyzerParameterElement(node);
+    scope.declare(
+        name.name,
+        name.staticElement = new AnalyzerParameterElement(node),
+        name.offset,
+        uri);
     push(node);
   }
 
   void endFormalParameters(
       int count, Token beginToken, Token endToken, MemberKind kind) {
     debugEvent("FormalParameters");
     List rawParameters = popList(count) ?? const <Object>[];
     List<FormalParameter> parameters = <FormalParameter>[];
     Token leftDelimiter;
     Token rightDelimiter;
@@ skipping 1018 matching lines @@
 
   /// Scans the given [code], and returns the tokens, otherwise returns `null`.
   Token _scanGenericMethodComment(String code, int offset) {
     var scanner = new SubStringScanner(offset, code);
     Token firstToken = scanner.tokenize();
     if (scanner.hasErrors) {
       return null;
     }
     return firstToken;
   }
+
+  @override
+  void addCompileTimeErrorFromMessage(FastaMessage message) {
+    library.addCompileTimeError(message.charOffset, message.message,
+        fileUri: message.uri);
+  }
 }
 
 /// Data structure placed on the stack to represent a class body.
 ///
 /// This is needed because analyzer has no separate AST representation of a
 /// class body; it simply stores all of the relevant data in the
 /// [ClassDeclaration] object.
 class _ClassBody {
   final Token beginToken;
 
@@ skipping 87 matching lines @@
       } else if (identical('var', s)) {
         finalConstOrVarKeyword = token;
       } else if (identical('covariant', s)) {
         covariantKeyword = token;
       } else {
         internalError('Unhandled modifier: $s');
       }
     }
   }
 }