Version 2.12.0-81.0.dev
Merge commit 'c8105305ac7372a3db3ffcba2fb5ad67092ce7d4' into 'dev'
diff --git a/pkg/front_end/lib/src/fasta/util/direct_parser_ast.dart b/pkg/front_end/lib/src/fasta/util/direct_parser_ast.dart
index 68b390d..aa4bc82 100644
--- a/pkg/front_end/lib/src/fasta/util/direct_parser_ast.dart
+++ b/pkg/front_end/lib/src/fasta/util/direct_parser_ast.dart
@@ -14,18 +14,15 @@
import 'package:_fe_analyzer_shared/src/scanner/token.dart' show Token;
-import 'package:front_end/src/fasta/util/direct_parser_ast_helper.dart'
- show
- AbstractDirectParserASTListener,
- DirectParserASTContent,
- DirectParserASTType;
+import 'package:front_end/src/fasta/util/direct_parser_ast_helper.dart';
-DirectParserASTContent getAST(List<int> rawBytes, {bool includeBody: true}) {
+DirectParserASTContentCompilationUnitEnd getAST(List<int> rawBytes,
+ {bool includeBody: true, bool includeComments: false}) {
Uint8List bytes = new Uint8List(rawBytes.length + 1);
bytes.setRange(0, rawBytes.length, rawBytes);
Utf8BytesScanner scanner =
- new Utf8BytesScanner(bytes, includeComments: false);
+ new Utf8BytesScanner(bytes, includeComments: includeComments);
Token firstToken = scanner.tokenize();
if (firstToken == null) {
throw "firstToken is null";
@@ -42,6 +39,264 @@
return listener.data.single;
}
+extension GeneralASTContentExtension on DirectParserASTContent {
+ bool isClass() {
+ if (this is! DirectParserASTContentTopLevelDeclarationEnd) {
+ return false;
+ }
+ if (children.first
+ is! DirectParserASTContentClassOrNamedMixinApplicationPreludeBegin) {
+ return false;
+ }
+ if (children.last is! DirectParserASTContentClassDeclarationEnd) {
+ return false;
+ }
+
+ return true;
+ }
+
+ List<E> recursivelyFind<E extends DirectParserASTContent>() {
+ Set<E> result = {};
+ _recursivelyFindInternal(this, result);
+ return result.toList();
+ }
+
+ static void _recursivelyFindInternal<E extends DirectParserASTContent>(
+ DirectParserASTContent node, Set<E> result) {
+ if (node is E) {
+ result.add(node);
+ return;
+ }
+ if (node.children == null) return;
+ for (DirectParserASTContent child in node.children) {
+ _recursivelyFindInternal(child, result);
+ }
+ }
+}
+
+extension CompilationUnitExtension on DirectParserASTContentCompilationUnitEnd {
+ List<DirectParserASTContentTopLevelDeclarationEnd> getClasses() {
+ List<DirectParserASTContentTopLevelDeclarationEnd> result = [];
+ for (DirectParserASTContent topLevel in children) {
+ if (!topLevel.isClass()) continue;
+ result.add(topLevel);
+ }
+ return result;
+ }
+
+ DirectParserASTContentCompilationUnitBegin getBegin() {
+ return children.first;
+ }
+}
+
+extension TopLevelDeclarationExtension
+ on DirectParserASTContentTopLevelDeclarationEnd {
+ DirectParserASTContentIdentifierHandle getClassIdentifier() {
+ if (!isClass()) {
+ throw "Not a class";
+ }
+ for (DirectParserASTContent child in children) {
+ if (child is DirectParserASTContentIdentifierHandle) return child;
+ }
+ throw "Not found.";
+ }
+
+ DirectParserASTContentClassDeclarationEnd getClassDeclaration() {
+ if (!isClass()) {
+ throw "Not a class";
+ }
+ for (DirectParserASTContent child in children) {
+ if (child is DirectParserASTContentClassDeclarationEnd) {
+ return child;
+ }
+ }
+ throw "Not found.";
+ }
+}
+
+extension ClassDeclaration on DirectParserASTContentClassDeclarationEnd {
+ DirectParserASTContentClassOrMixinBodyEnd getClassOrMixinBody() {
+ for (DirectParserASTContent child in children) {
+ if (child is DirectParserASTContentClassOrMixinBodyEnd) return child;
+ }
+ throw "Not found.";
+ }
+
+ DirectParserASTContentClassExtendsHandle getClassExtends() {
+ for (DirectParserASTContent child in children) {
+ if (child is DirectParserASTContentClassExtendsHandle) return child;
+ }
+ throw "Not found.";
+ }
+}
+
+extension ClassOrMixinBodyExtension
+ on DirectParserASTContentClassOrMixinBodyEnd {
+ List<DirectParserASTContentMemberEnd> getMembers() {
+ List<DirectParserASTContentMemberEnd> members = [];
+ for (DirectParserASTContent child in children) {
+ if (child is DirectParserASTContentMemberEnd) {
+ members.add(child);
+ }
+ }
+ return members;
+ }
+}
+
+extension MemberExtension on DirectParserASTContentMemberEnd {
+ bool isClassConstructor() {
+ DirectParserASTContent child = children[1];
+ if (child is DirectParserASTContentClassConstructorEnd) return true;
+ return false;
+ }
+
+ DirectParserASTContentClassConstructorEnd getClassConstructor() {
+ DirectParserASTContent child = children[1];
+ if (child is DirectParserASTContentClassConstructorEnd) return child;
+ throw "Not found";
+ }
+
+ bool isClassFields() {
+ DirectParserASTContent child = children[1];
+ if (child is DirectParserASTContentClassFieldsEnd) return true;
+ return false;
+ }
+
+ DirectParserASTContentClassFieldsEnd getClassFields() {
+ DirectParserASTContent child = children[1];
+ if (child is DirectParserASTContentClassFieldsEnd) return child;
+ throw "Not found";
+ }
+}
+
+extension ClassFieldsExtension on DirectParserASTContentClassFieldsEnd {
+ List<DirectParserASTContentIdentifierHandle> getFieldIdentifiers() {
+ // For now blindly assume that the last count identifiers are the names
+ // of the fields.
+ int countLeft = count;
+ List<DirectParserASTContentIdentifierHandle> identifiers =
+ new List<DirectParserASTContentIdentifierHandle>(count);
+ for (int i = children.length - 1; i >= 0; i--) {
+ DirectParserASTContent child = children[i];
+ if (child is DirectParserASTContentIdentifierHandle) {
+ countLeft--;
+ identifiers[countLeft] = child;
+ if (countLeft == 0) break;
+ }
+ }
+ if (countLeft != 0) throw "Didn't find the expected number of identifiers";
+ return identifiers;
+ }
+
+ DirectParserASTContentTypeHandle getFirstType() {
+ for (DirectParserASTContent child in children) {
+ if (child is DirectParserASTContentTypeHandle) return child;
+ }
+ return null;
+ }
+
+ DirectParserASTContentFieldInitializerEnd getFieldInitializer() {
+ for (DirectParserASTContent child in children) {
+ if (child is DirectParserASTContentFieldInitializerEnd) return child;
+ }
+ return null;
+ }
+}
+
+extension ClassConstructorExtension
+ on DirectParserASTContentClassConstructorEnd {
+ DirectParserASTContentFormalParametersEnd getFormalParameters() {
+ for (DirectParserASTContent child in children) {
+ if (child is DirectParserASTContentFormalParametersEnd) {
+ return child;
+ }
+ }
+ throw "Not found";
+ }
+
+ DirectParserASTContentInitializersEnd getInitializers() {
+ for (DirectParserASTContent child in children) {
+ if (child is DirectParserASTContentInitializersEnd) {
+ return child;
+ }
+ }
+ return null;
+ }
+
+ DirectParserASTContentBlockFunctionBodyEnd getBlockFunctionBody() {
+ for (DirectParserASTContent child in children) {
+ if (child is DirectParserASTContentBlockFunctionBodyEnd) {
+ return child;
+ }
+ }
+ return null;
+ }
+}
+
+extension FormalParametersExtension
+ on DirectParserASTContentFormalParametersEnd {
+ List<DirectParserASTContentFormalParameterEnd> getFormalParameters() {
+ List<DirectParserASTContentFormalParameterEnd> result = [];
+ for (DirectParserASTContent child in children) {
+ if (child is DirectParserASTContentFormalParameterEnd) {
+ result.add(child);
+ }
+ }
+ return result;
+ }
+
+ DirectParserASTContentOptionalFormalParametersEnd
+ getOptionalFormalParameters() {
+ for (DirectParserASTContent child in children) {
+ if (child is DirectParserASTContentOptionalFormalParametersEnd) {
+ return child;
+ }
+ }
+ return null;
+ }
+}
+
+extension FormalParameterExtension on DirectParserASTContentFormalParameterEnd {
+ DirectParserASTContentFormalParameterBegin getBegin() {
+ return children.first;
+ }
+}
+
+extension OptionalFormalParametersExtension
+ on DirectParserASTContentOptionalFormalParametersEnd {
+ List<DirectParserASTContentFormalParameterEnd> getFormalParameters() {
+ List<DirectParserASTContentFormalParameterEnd> result = [];
+ for (DirectParserASTContent child in children) {
+ if (child is DirectParserASTContentFormalParameterEnd) {
+ result.add(child);
+ }
+ }
+ return result;
+ }
+}
+
+extension InitializersExtension on DirectParserASTContentInitializersEnd {
+ List<DirectParserASTContentInitializerEnd> getInitializers() {
+ List<DirectParserASTContentInitializerEnd> result = [];
+ for (DirectParserASTContent child in children) {
+ if (child is DirectParserASTContentInitializerEnd) {
+ result.add(child);
+ }
+ }
+ return result;
+ }
+
+ DirectParserASTContentInitializersBegin getBegin() {
+ return children.first;
+ }
+}
+
+extension InitializerExtension on DirectParserASTContentInitializerEnd {
+ DirectParserASTContentInitializerBegin getBegin() {
+ return children.first;
+ }
+}
+
main(List<String> args) {
File f = new File(args[0]);
Uint8List data = f.readAsBytesSync();
@@ -75,17 +330,13 @@
}
class DirectParserASTListener extends AbstractDirectParserASTListener {
- void seen(
- String what, DirectParserASTType type, Map<String, Object> arguments) {
- switch (type) {
+ void seen(DirectParserASTContent entry) {
+ switch (entry.type) {
case DirectParserASTType.BEGIN:
case DirectParserASTType.HANDLE:
// This just adds stuff.
- data.add(new DirectParserASTContent(what, type, arguments));
+ data.add(entry);
break;
- case DirectParserASTType.DONE:
- // This shouldn't be seen. It's artificial.
- throw new StateError("Saw type 'DONE'");
case DirectParserASTType.END:
// End should gobble up everything until the corresponding begin (which
// should be the latest begin).
@@ -97,11 +348,11 @@
}
}
if (beginIndex == null) {
- throw "Couldn't find a begin for $what. Has:\n"
+ throw "Couldn't find a begin for ${entry.what}. Has:\n"
"${data.map((e) => "${e.what}: ${e.type}").join("\n")}";
}
String begin = data[beginIndex].what;
- String end = what;
+ String end = entry.what;
if (begin == end) {
// Exact match.
} else if (end == "TopLevelDeclaration" &&
@@ -154,11 +405,9 @@
} else {
throw "Unknown combination: begin$begin and end$end";
}
- List<DirectParserASTContent> content = data.sublist(beginIndex);
+ List<DirectParserASTContent> children = data.sublist(beginIndex);
data.length = beginIndex;
- data.add(new DirectParserASTContent(
- what, DirectParserASTType.DONE, arguments)
- ..content = content);
+ data.add(entry..children = children);
break;
}
}
diff --git a/pkg/front_end/lib/src/fasta/util/direct_parser_ast_helper.dart b/pkg/front_end/lib/src/fasta/util/direct_parser_ast_helper.dart
index 7da31a4..70be181 100644
--- a/pkg/front_end/lib/src/fasta/util/direct_parser_ast_helper.dart
+++ b/pkg/front_end/lib/src/fasta/util/direct_parser_ast_helper.dart
@@ -13,6 +13,8 @@
import 'package:_fe_analyzer_shared/src/scanner/token.dart';
import 'package:front_end/src/fasta/messages.dart';
+// ignore_for_file: lines_longer_than_80_chars
+
// THIS FILE IS AUTO GENERATED BY
// 'tool/_fasta/direct_parser_ast_helper_creator.dart'
// Run e.g.
@@ -22,339 +24,493 @@
> pkg/front_end/lib/src/fasta/util/direct_parser_ast_helper.dart
*/
-class DirectParserASTContent {
+abstract class DirectParserASTContent {
final String what;
final DirectParserASTType type;
- final Map<String, Object> arguments;
- List<DirectParserASTContent> content;
+ Map<String, Object> get deprecatedArguments;
+ List<DirectParserASTContent> children;
- DirectParserASTContent(this.what, this.type, this.arguments);
+ DirectParserASTContent(this.what, this.type);
// TODO(jensj): Compare two ASTs.
}
-enum DirectParserASTType { BEGIN, END, HANDLE, DONE }
+enum DirectParserASTType { BEGIN, END, HANDLE }
abstract class AbstractDirectParserASTListener implements Listener {
List<DirectParserASTContent> data = [];
- void seen(
- String what, DirectParserASTType type, Map<String, Object> arguments);
+ void seen(DirectParserASTContent entry);
void beginArguments(Token token) {
- seen("Arguments", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentArgumentsBegin data =
+ new DirectParserASTContentArgumentsBegin(DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void endArguments(int count, Token beginToken, Token endToken) {
- seen("Arguments", DirectParserASTType.END,
- {"count": count, "beginToken": beginToken, "endToken": endToken});
+ DirectParserASTContentArgumentsEnd data =
+ new DirectParserASTContentArgumentsEnd(DirectParserASTType.END,
+ count: count, beginToken: beginToken, endToken: endToken);
+ seen(data);
}
void handleAsyncModifier(Token asyncToken, Token starToken) {
- seen("AsyncModifier", DirectParserASTType.HANDLE,
- {"asyncToken": asyncToken, "starToken": starToken});
+ DirectParserASTContentAsyncModifierHandle data =
+ new DirectParserASTContentAsyncModifierHandle(
+ DirectParserASTType.HANDLE,
+ asyncToken: asyncToken,
+ starToken: starToken);
+ seen(data);
}
void beginAwaitExpression(Token token) {
- seen("AwaitExpression", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentAwaitExpressionBegin data =
+ new DirectParserASTContentAwaitExpressionBegin(
+ DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void endAwaitExpression(Token beginToken, Token endToken) {
- seen("AwaitExpression", DirectParserASTType.END,
- {"beginToken": beginToken, "endToken": endToken});
+ DirectParserASTContentAwaitExpressionEnd data =
+ new DirectParserASTContentAwaitExpressionEnd(DirectParserASTType.END,
+ beginToken: beginToken, endToken: endToken);
+ seen(data);
}
void endInvalidAwaitExpression(
Token beginToken, Token endToken, MessageCode errorCode) {
- seen("InvalidAwaitExpression", DirectParserASTType.END, {
- "beginToken": beginToken,
- "endToken": endToken,
- "errorCode": errorCode
- });
+ DirectParserASTContentInvalidAwaitExpressionEnd data =
+ new DirectParserASTContentInvalidAwaitExpressionEnd(
+ DirectParserASTType.END,
+ beginToken: beginToken,
+ endToken: endToken,
+ errorCode: errorCode);
+ seen(data);
}
void beginBlock(Token token, BlockKind blockKind) {
- seen("Block", DirectParserASTType.BEGIN,
- {"token": token, "blockKind": blockKind});
+ DirectParserASTContentBlockBegin data =
+ new DirectParserASTContentBlockBegin(DirectParserASTType.BEGIN,
+ token: token, blockKind: blockKind);
+ seen(data);
}
void endBlock(
int count, Token beginToken, Token endToken, BlockKind blockKind) {
- seen("Block", DirectParserASTType.END, {
- "count": count,
- "beginToken": beginToken,
- "endToken": endToken,
- "blockKind": blockKind
- });
+ DirectParserASTContentBlockEnd data = new DirectParserASTContentBlockEnd(
+ DirectParserASTType.END,
+ count: count,
+ beginToken: beginToken,
+ endToken: endToken,
+ blockKind: blockKind);
+ seen(data);
}
void handleInvalidTopLevelBlock(Token token) {
- seen("InvalidTopLevelBlock", DirectParserASTType.HANDLE, {"token": token});
+ DirectParserASTContentInvalidTopLevelBlockHandle data =
+ new DirectParserASTContentInvalidTopLevelBlockHandle(
+ DirectParserASTType.HANDLE,
+ token: token);
+ seen(data);
}
void beginCascade(Token token) {
- seen("Cascade", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentCascadeBegin data =
+ new DirectParserASTContentCascadeBegin(DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void endCascade() {
- seen("Cascade", DirectParserASTType.END, {});
+ DirectParserASTContentCascadeEnd data =
+ new DirectParserASTContentCascadeEnd(DirectParserASTType.END);
+ seen(data);
}
void beginCaseExpression(Token caseKeyword) {
- seen("CaseExpression", DirectParserASTType.BEGIN,
- {"caseKeyword": caseKeyword});
+ DirectParserASTContentCaseExpressionBegin data =
+ new DirectParserASTContentCaseExpressionBegin(DirectParserASTType.BEGIN,
+ caseKeyword: caseKeyword);
+ seen(data);
}
void endCaseExpression(Token colon) {
- seen("CaseExpression", DirectParserASTType.END, {"colon": colon});
+ DirectParserASTContentCaseExpressionEnd data =
+ new DirectParserASTContentCaseExpressionEnd(DirectParserASTType.END,
+ colon: colon);
+ seen(data);
}
void beginClassOrMixinBody(DeclarationKind kind, Token token) {
- seen("ClassOrMixinBody", DirectParserASTType.BEGIN,
- {"kind": kind, "token": token});
+ DirectParserASTContentClassOrMixinBodyBegin data =
+ new DirectParserASTContentClassOrMixinBodyBegin(
+ DirectParserASTType.BEGIN,
+ kind: kind,
+ token: token);
+ seen(data);
}
void endClassOrMixinBody(
DeclarationKind kind, int memberCount, Token beginToken, Token endToken) {
- seen("ClassOrMixinBody", DirectParserASTType.END, {
- "kind": kind,
- "memberCount": memberCount,
- "beginToken": beginToken,
- "endToken": endToken
- });
+ DirectParserASTContentClassOrMixinBodyEnd data =
+ new DirectParserASTContentClassOrMixinBodyEnd(DirectParserASTType.END,
+ kind: kind,
+ memberCount: memberCount,
+ beginToken: beginToken,
+ endToken: endToken);
+ seen(data);
}
void beginClassOrNamedMixinApplicationPrelude(Token token) {
- seen("ClassOrNamedMixinApplicationPrelude", DirectParserASTType.BEGIN,
- {"token": token});
+ DirectParserASTContentClassOrNamedMixinApplicationPreludeBegin data =
+ new DirectParserASTContentClassOrNamedMixinApplicationPreludeBegin(
+ DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void beginClassDeclaration(Token begin, Token abstractToken, Token name) {
- seen("ClassDeclaration", DirectParserASTType.BEGIN,
- {"begin": begin, "abstractToken": abstractToken, "name": name});
+ DirectParserASTContentClassDeclarationBegin data =
+ new DirectParserASTContentClassDeclarationBegin(
+ DirectParserASTType.BEGIN,
+ begin: begin,
+ abstractToken: abstractToken,
+ name: name);
+ seen(data);
}
void handleClassExtends(Token extendsKeyword, int typeCount) {
- seen("ClassExtends", DirectParserASTType.HANDLE,
- {"extendsKeyword": extendsKeyword, "typeCount": typeCount});
+ DirectParserASTContentClassExtendsHandle data =
+ new DirectParserASTContentClassExtendsHandle(DirectParserASTType.HANDLE,
+ extendsKeyword: extendsKeyword, typeCount: typeCount);
+ seen(data);
}
void handleClassOrMixinImplements(
Token implementsKeyword, int interfacesCount) {
- seen("ClassOrMixinImplements", DirectParserASTType.HANDLE, {
- "implementsKeyword": implementsKeyword,
- "interfacesCount": interfacesCount
- });
+ DirectParserASTContentClassOrMixinImplementsHandle data =
+ new DirectParserASTContentClassOrMixinImplementsHandle(
+ DirectParserASTType.HANDLE,
+ implementsKeyword: implementsKeyword,
+ interfacesCount: interfacesCount);
+ seen(data);
}
void handleClassHeader(Token begin, Token classKeyword, Token nativeToken) {
- seen("ClassHeader", DirectParserASTType.HANDLE, {
- "begin": begin,
- "classKeyword": classKeyword,
- "nativeToken": nativeToken
- });
+ DirectParserASTContentClassHeaderHandle data =
+ new DirectParserASTContentClassHeaderHandle(DirectParserASTType.HANDLE,
+ begin: begin, classKeyword: classKeyword, nativeToken: nativeToken);
+ seen(data);
}
void handleRecoverClassHeader() {
- seen("RecoverClassHeader", DirectParserASTType.HANDLE, {});
+ DirectParserASTContentRecoverClassHeaderHandle data =
+ new DirectParserASTContentRecoverClassHeaderHandle(
+ DirectParserASTType.HANDLE);
+ seen(data);
}
void endClassDeclaration(Token beginToken, Token endToken) {
- seen("ClassDeclaration", DirectParserASTType.END,
- {"beginToken": beginToken, "endToken": endToken});
+ DirectParserASTContentClassDeclarationEnd data =
+ new DirectParserASTContentClassDeclarationEnd(DirectParserASTType.END,
+ beginToken: beginToken, endToken: endToken);
+ seen(data);
}
void beginMixinDeclaration(Token mixinKeyword, Token name) {
- seen("MixinDeclaration", DirectParserASTType.BEGIN,
- {"mixinKeyword": mixinKeyword, "name": name});
+ DirectParserASTContentMixinDeclarationBegin data =
+ new DirectParserASTContentMixinDeclarationBegin(
+ DirectParserASTType.BEGIN,
+ mixinKeyword: mixinKeyword,
+ name: name);
+ seen(data);
}
void handleMixinOn(Token onKeyword, int typeCount) {
- seen("MixinOn", DirectParserASTType.HANDLE,
- {"onKeyword": onKeyword, "typeCount": typeCount});
+ DirectParserASTContentMixinOnHandle data =
+ new DirectParserASTContentMixinOnHandle(DirectParserASTType.HANDLE,
+ onKeyword: onKeyword, typeCount: typeCount);
+ seen(data);
}
void handleMixinHeader(Token mixinKeyword) {
- seen("MixinHeader", DirectParserASTType.HANDLE,
- {"mixinKeyword": mixinKeyword});
+ DirectParserASTContentMixinHeaderHandle data =
+ new DirectParserASTContentMixinHeaderHandle(DirectParserASTType.HANDLE,
+ mixinKeyword: mixinKeyword);
+ seen(data);
}
void handleRecoverMixinHeader() {
- seen("RecoverMixinHeader", DirectParserASTType.HANDLE, {});
+ DirectParserASTContentRecoverMixinHeaderHandle data =
+ new DirectParserASTContentRecoverMixinHeaderHandle(
+ DirectParserASTType.HANDLE);
+ seen(data);
}
void endMixinDeclaration(Token mixinKeyword, Token endToken) {
- seen("MixinDeclaration", DirectParserASTType.END,
- {"mixinKeyword": mixinKeyword, "endToken": endToken});
+ DirectParserASTContentMixinDeclarationEnd data =
+ new DirectParserASTContentMixinDeclarationEnd(DirectParserASTType.END,
+ mixinKeyword: mixinKeyword, endToken: endToken);
+ seen(data);
}
void beginUncategorizedTopLevelDeclaration(Token token) {
- seen("UncategorizedTopLevelDeclaration", DirectParserASTType.BEGIN,
- {"token": token});
+ DirectParserASTContentUncategorizedTopLevelDeclarationBegin data =
+ new DirectParserASTContentUncategorizedTopLevelDeclarationBegin(
+ DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void beginExtensionDeclarationPrelude(Token extensionKeyword) {
- seen("ExtensionDeclarationPrelude", DirectParserASTType.BEGIN,
- {"extensionKeyword": extensionKeyword});
+ DirectParserASTContentExtensionDeclarationPreludeBegin data =
+ new DirectParserASTContentExtensionDeclarationPreludeBegin(
+ DirectParserASTType.BEGIN,
+ extensionKeyword: extensionKeyword);
+ seen(data);
}
void beginExtensionDeclaration(Token extensionKeyword, Token name) {
- seen("ExtensionDeclaration", DirectParserASTType.BEGIN,
- {"extensionKeyword": extensionKeyword, "name": name});
+ DirectParserASTContentExtensionDeclarationBegin data =
+ new DirectParserASTContentExtensionDeclarationBegin(
+ DirectParserASTType.BEGIN,
+ extensionKeyword: extensionKeyword,
+ name: name);
+ seen(data);
}
void endExtensionDeclaration(
Token extensionKeyword, Token onKeyword, Token endToken) {
- seen("ExtensionDeclaration", DirectParserASTType.END, {
- "extensionKeyword": extensionKeyword,
- "onKeyword": onKeyword,
- "endToken": endToken
- });
+ DirectParserASTContentExtensionDeclarationEnd data =
+ new DirectParserASTContentExtensionDeclarationEnd(
+ DirectParserASTType.END,
+ extensionKeyword: extensionKeyword,
+ onKeyword: onKeyword,
+ endToken: endToken);
+ seen(data);
}
void beginCombinators(Token token) {
- seen("Combinators", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentCombinatorsBegin data =
+ new DirectParserASTContentCombinatorsBegin(DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void endCombinators(int count) {
- seen("Combinators", DirectParserASTType.END, {"count": count});
+ DirectParserASTContentCombinatorsEnd data =
+ new DirectParserASTContentCombinatorsEnd(DirectParserASTType.END,
+ count: count);
+ seen(data);
}
void beginCompilationUnit(Token token) {
- seen("CompilationUnit", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentCompilationUnitBegin data =
+ new DirectParserASTContentCompilationUnitBegin(
+ DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void handleDirectivesOnly() {
- seen("DirectivesOnly", DirectParserASTType.HANDLE, {});
+ DirectParserASTContentDirectivesOnlyHandle data =
+ new DirectParserASTContentDirectivesOnlyHandle(
+ DirectParserASTType.HANDLE);
+ seen(data);
}
void endCompilationUnit(int count, Token token) {
- seen("CompilationUnit", DirectParserASTType.END,
- {"count": count, "token": token});
+ DirectParserASTContentCompilationUnitEnd data =
+ new DirectParserASTContentCompilationUnitEnd(DirectParserASTType.END,
+ count: count, token: token);
+ seen(data);
}
void beginConstLiteral(Token token) {
- seen("ConstLiteral", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentConstLiteralBegin data =
+ new DirectParserASTContentConstLiteralBegin(DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void endConstLiteral(Token token) {
- seen("ConstLiteral", DirectParserASTType.END, {"token": token});
+ DirectParserASTContentConstLiteralEnd data =
+ new DirectParserASTContentConstLiteralEnd(DirectParserASTType.END,
+ token: token);
+ seen(data);
}
void beginConstructorReference(Token start) {
- seen("ConstructorReference", DirectParserASTType.BEGIN, {"start": start});
+ DirectParserASTContentConstructorReferenceBegin data =
+ new DirectParserASTContentConstructorReferenceBegin(
+ DirectParserASTType.BEGIN,
+ start: start);
+ seen(data);
}
void endConstructorReference(
Token start, Token periodBeforeName, Token endToken) {
- seen("ConstructorReference", DirectParserASTType.END, {
- "start": start,
- "periodBeforeName": periodBeforeName,
- "endToken": endToken
- });
+ DirectParserASTContentConstructorReferenceEnd data =
+ new DirectParserASTContentConstructorReferenceEnd(
+ DirectParserASTType.END,
+ start: start,
+ periodBeforeName: periodBeforeName,
+ endToken: endToken);
+ seen(data);
}
void beginDoWhileStatement(Token token) {
- seen("DoWhileStatement", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentDoWhileStatementBegin data =
+ new DirectParserASTContentDoWhileStatementBegin(
+ DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void endDoWhileStatement(
Token doKeyword, Token whileKeyword, Token endToken) {
- seen("DoWhileStatement", DirectParserASTType.END, {
- "doKeyword": doKeyword,
- "whileKeyword": whileKeyword,
- "endToken": endToken
- });
+ DirectParserASTContentDoWhileStatementEnd data =
+ new DirectParserASTContentDoWhileStatementEnd(DirectParserASTType.END,
+ doKeyword: doKeyword,
+ whileKeyword: whileKeyword,
+ endToken: endToken);
+ seen(data);
}
void beginDoWhileStatementBody(Token token) {
- seen("DoWhileStatementBody", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentDoWhileStatementBodyBegin data =
+ new DirectParserASTContentDoWhileStatementBodyBegin(
+ DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void endDoWhileStatementBody(Token token) {
- seen("DoWhileStatementBody", DirectParserASTType.END, {"token": token});
+ DirectParserASTContentDoWhileStatementBodyEnd data =
+ new DirectParserASTContentDoWhileStatementBodyEnd(
+ DirectParserASTType.END,
+ token: token);
+ seen(data);
}
void beginWhileStatementBody(Token token) {
- seen("WhileStatementBody", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentWhileStatementBodyBegin data =
+ new DirectParserASTContentWhileStatementBodyBegin(
+ DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void endWhileStatementBody(Token token) {
- seen("WhileStatementBody", DirectParserASTType.END, {"token": token});
+ DirectParserASTContentWhileStatementBodyEnd data =
+ new DirectParserASTContentWhileStatementBodyEnd(DirectParserASTType.END,
+ token: token);
+ seen(data);
}
void beginEnum(Token enumKeyword) {
- seen("Enum", DirectParserASTType.BEGIN, {"enumKeyword": enumKeyword});
+ DirectParserASTContentEnumBegin data = new DirectParserASTContentEnumBegin(
+ DirectParserASTType.BEGIN,
+ enumKeyword: enumKeyword);
+ seen(data);
}
void endEnum(Token enumKeyword, Token leftBrace, int count) {
- seen("Enum", DirectParserASTType.END,
- {"enumKeyword": enumKeyword, "leftBrace": leftBrace, "count": count});
+ DirectParserASTContentEnumEnd data = new DirectParserASTContentEnumEnd(
+ DirectParserASTType.END,
+ enumKeyword: enumKeyword,
+ leftBrace: leftBrace,
+ count: count);
+ seen(data);
}
void beginExport(Token token) {
- seen("Export", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentExportBegin data =
+ new DirectParserASTContentExportBegin(DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void endExport(Token exportKeyword, Token semicolon) {
- seen("Export", DirectParserASTType.END,
- {"exportKeyword": exportKeyword, "semicolon": semicolon});
+ DirectParserASTContentExportEnd data = new DirectParserASTContentExportEnd(
+ DirectParserASTType.END,
+ exportKeyword: exportKeyword,
+ semicolon: semicolon);
+ seen(data);
}
void handleExtraneousExpression(Token token, Message message) {
- seen("ExtraneousExpression", DirectParserASTType.HANDLE,
- {"token": token, "message": message});
+ DirectParserASTContentExtraneousExpressionHandle data =
+ new DirectParserASTContentExtraneousExpressionHandle(
+ DirectParserASTType.HANDLE,
+ token: token,
+ message: message);
+ seen(data);
}
void handleExpressionStatement(Token token) {
- seen("ExpressionStatement", DirectParserASTType.HANDLE, {"token": token});
+ DirectParserASTContentExpressionStatementHandle data =
+ new DirectParserASTContentExpressionStatementHandle(
+ DirectParserASTType.HANDLE,
+ token: token);
+ seen(data);
}
void beginFactoryMethod(
Token lastConsumed, Token externalToken, Token constToken) {
- seen("FactoryMethod", DirectParserASTType.BEGIN, {
- "lastConsumed": lastConsumed,
- "externalToken": externalToken,
- "constToken": constToken
- });
+ DirectParserASTContentFactoryMethodBegin data =
+ new DirectParserASTContentFactoryMethodBegin(DirectParserASTType.BEGIN,
+ lastConsumed: lastConsumed,
+ externalToken: externalToken,
+ constToken: constToken);
+ seen(data);
}
void endClassFactoryMethod(
Token beginToken, Token factoryKeyword, Token endToken) {
- seen("ClassFactoryMethod", DirectParserASTType.END, {
- "beginToken": beginToken,
- "factoryKeyword": factoryKeyword,
- "endToken": endToken
- });
+ DirectParserASTContentClassFactoryMethodEnd data =
+ new DirectParserASTContentClassFactoryMethodEnd(DirectParserASTType.END,
+ beginToken: beginToken,
+ factoryKeyword: factoryKeyword,
+ endToken: endToken);
+ seen(data);
}
void endMixinFactoryMethod(
Token beginToken, Token factoryKeyword, Token endToken) {
- seen("MixinFactoryMethod", DirectParserASTType.END, {
- "beginToken": beginToken,
- "factoryKeyword": factoryKeyword,
- "endToken": endToken
- });
+ DirectParserASTContentMixinFactoryMethodEnd data =
+ new DirectParserASTContentMixinFactoryMethodEnd(DirectParserASTType.END,
+ beginToken: beginToken,
+ factoryKeyword: factoryKeyword,
+ endToken: endToken);
+ seen(data);
}
void endExtensionFactoryMethod(
Token beginToken, Token factoryKeyword, Token endToken) {
- seen("ExtensionFactoryMethod", DirectParserASTType.END, {
- "beginToken": beginToken,
- "factoryKeyword": factoryKeyword,
- "endToken": endToken
- });
+ DirectParserASTContentExtensionFactoryMethodEnd data =
+ new DirectParserASTContentExtensionFactoryMethodEnd(
+ DirectParserASTType.END,
+ beginToken: beginToken,
+ factoryKeyword: factoryKeyword,
+ endToken: endToken);
+ seen(data);
}
void beginFormalParameter(Token token, MemberKind kind, Token requiredToken,
Token covariantToken, Token varFinalOrConst) {
- seen("FormalParameter", DirectParserASTType.BEGIN, {
- "token": token,
- "kind": kind,
- "requiredToken": requiredToken,
- "covariantToken": covariantToken,
- "varFinalOrConst": varFinalOrConst
- });
+ DirectParserASTContentFormalParameterBegin data =
+ new DirectParserASTContentFormalParameterBegin(
+ DirectParserASTType.BEGIN,
+ token: token,
+ kind: kind,
+ requiredToken: requiredToken,
+ covariantToken: covariantToken,
+ varFinalOrConst: varFinalOrConst);
+ seen(data);
}
void endFormalParameter(
@@ -365,35 +521,45 @@
Token initializerEnd,
FormalParameterKind kind,
MemberKind memberKind) {
- seen("FormalParameter", DirectParserASTType.END, {
- "thisKeyword": thisKeyword,
- "periodAfterThis": periodAfterThis,
- "nameToken": nameToken,
- "initializerStart": initializerStart,
- "initializerEnd": initializerEnd,
- "kind": kind,
- "memberKind": memberKind
- });
+ DirectParserASTContentFormalParameterEnd data =
+ new DirectParserASTContentFormalParameterEnd(DirectParserASTType.END,
+ thisKeyword: thisKeyword,
+ periodAfterThis: periodAfterThis,
+ nameToken: nameToken,
+ initializerStart: initializerStart,
+ initializerEnd: initializerEnd,
+ kind: kind,
+ memberKind: memberKind);
+ seen(data);
}
void handleNoFormalParameters(Token token, MemberKind kind) {
- seen("NoFormalParameters", DirectParserASTType.HANDLE,
- {"token": token, "kind": kind});
+ DirectParserASTContentNoFormalParametersHandle data =
+ new DirectParserASTContentNoFormalParametersHandle(
+ DirectParserASTType.HANDLE,
+ token: token,
+ kind: kind);
+ seen(data);
}
void beginFormalParameters(Token token, MemberKind kind) {
- seen("FormalParameters", DirectParserASTType.BEGIN,
- {"token": token, "kind": kind});
+ DirectParserASTContentFormalParametersBegin data =
+ new DirectParserASTContentFormalParametersBegin(
+ DirectParserASTType.BEGIN,
+ token: token,
+ kind: kind);
+ seen(data);
}
void endFormalParameters(
int count, Token beginToken, Token endToken, MemberKind kind) {
- seen("FormalParameters", DirectParserASTType.END, {
- "count": count,
- "beginToken": beginToken,
- "endToken": endToken,
- "kind": kind
- });
+ DirectParserASTContentFormalParametersEnd data =
+ new DirectParserASTContentFormalParametersEnd(DirectParserASTType.END,
+ count: count,
+ beginToken: beginToken,
+ endToken: endToken,
+ kind: kind);
+ seen(data);
}
void endClassFields(
@@ -406,17 +572,18 @@
int count,
Token beginToken,
Token endToken) {
- seen("ClassFields", DirectParserASTType.END, {
- "abstractToken": abstractToken,
- "externalToken": externalToken,
- "staticToken": staticToken,
- "covariantToken": covariantToken,
- "lateToken": lateToken,
- "varFinalOrConst": varFinalOrConst,
- "count": count,
- "beginToken": beginToken,
- "endToken": endToken
- });
+ DirectParserASTContentClassFieldsEnd data =
+ new DirectParserASTContentClassFieldsEnd(DirectParserASTType.END,
+ abstractToken: abstractToken,
+ externalToken: externalToken,
+ staticToken: staticToken,
+ covariantToken: covariantToken,
+ lateToken: lateToken,
+ varFinalOrConst: varFinalOrConst,
+ count: count,
+ beginToken: beginToken,
+ endToken: endToken);
+ seen(data);
}
void endMixinFields(
@@ -429,17 +596,18 @@
int count,
Token beginToken,
Token endToken) {
- seen("MixinFields", DirectParserASTType.END, {
- "abstractToken": abstractToken,
- "externalToken": externalToken,
- "staticToken": staticToken,
- "covariantToken": covariantToken,
- "lateToken": lateToken,
- "varFinalOrConst": varFinalOrConst,
- "count": count,
- "beginToken": beginToken,
- "endToken": endToken
- });
+ DirectParserASTContentMixinFieldsEnd data =
+ new DirectParserASTContentMixinFieldsEnd(DirectParserASTType.END,
+ abstractToken: abstractToken,
+ externalToken: externalToken,
+ staticToken: staticToken,
+ covariantToken: covariantToken,
+ lateToken: lateToken,
+ varFinalOrConst: varFinalOrConst,
+ count: count,
+ beginToken: beginToken,
+ endToken: endToken);
+ seen(data);
}
void endExtensionFields(
@@ -452,658 +620,1018 @@
int count,
Token beginToken,
Token endToken) {
- seen("ExtensionFields", DirectParserASTType.END, {
- "abstractToken": abstractToken,
- "externalToken": externalToken,
- "staticToken": staticToken,
- "covariantToken": covariantToken,
- "lateToken": lateToken,
- "varFinalOrConst": varFinalOrConst,
- "count": count,
- "beginToken": beginToken,
- "endToken": endToken
- });
+ DirectParserASTContentExtensionFieldsEnd data =
+ new DirectParserASTContentExtensionFieldsEnd(DirectParserASTType.END,
+ abstractToken: abstractToken,
+ externalToken: externalToken,
+ staticToken: staticToken,
+ covariantToken: covariantToken,
+ lateToken: lateToken,
+ varFinalOrConst: varFinalOrConst,
+ count: count,
+ beginToken: beginToken,
+ endToken: endToken);
+ seen(data);
}
void handleForInitializerEmptyStatement(Token token) {
- seen("ForInitializerEmptyStatement", DirectParserASTType.HANDLE,
- {"token": token});
+ DirectParserASTContentForInitializerEmptyStatementHandle data =
+ new DirectParserASTContentForInitializerEmptyStatementHandle(
+ DirectParserASTType.HANDLE,
+ token: token);
+ seen(data);
}
void handleForInitializerExpressionStatement(Token token, bool forIn) {
- seen("ForInitializerExpressionStatement", DirectParserASTType.HANDLE,
- {"token": token, "forIn": forIn});
+ DirectParserASTContentForInitializerExpressionStatementHandle data =
+ new DirectParserASTContentForInitializerExpressionStatementHandle(
+ DirectParserASTType.HANDLE,
+ token: token,
+ forIn: forIn);
+ seen(data);
}
void handleForInitializerLocalVariableDeclaration(Token token, bool forIn) {
- seen("ForInitializerLocalVariableDeclaration", DirectParserASTType.HANDLE,
- {"token": token, "forIn": forIn});
+ DirectParserASTContentForInitializerLocalVariableDeclarationHandle data =
+ new DirectParserASTContentForInitializerLocalVariableDeclarationHandle(
+ DirectParserASTType.HANDLE,
+ token: token,
+ forIn: forIn);
+ seen(data);
}
void beginForStatement(Token token) {
- seen("ForStatement", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentForStatementBegin data =
+ new DirectParserASTContentForStatementBegin(DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void handleForLoopParts(Token forKeyword, Token leftParen,
Token leftSeparator, int updateExpressionCount) {
- seen("ForLoopParts", DirectParserASTType.HANDLE, {
- "forKeyword": forKeyword,
- "leftParen": leftParen,
- "leftSeparator": leftSeparator,
- "updateExpressionCount": updateExpressionCount
- });
+ DirectParserASTContentForLoopPartsHandle data =
+ new DirectParserASTContentForLoopPartsHandle(DirectParserASTType.HANDLE,
+ forKeyword: forKeyword,
+ leftParen: leftParen,
+ leftSeparator: leftSeparator,
+ updateExpressionCount: updateExpressionCount);
+ seen(data);
}
void endForStatement(Token endToken) {
- seen("ForStatement", DirectParserASTType.END, {"endToken": endToken});
+ DirectParserASTContentForStatementEnd data =
+ new DirectParserASTContentForStatementEnd(DirectParserASTType.END,
+ endToken: endToken);
+ seen(data);
}
void beginForStatementBody(Token token) {
- seen("ForStatementBody", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentForStatementBodyBegin data =
+ new DirectParserASTContentForStatementBodyBegin(
+ DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void endForStatementBody(Token token) {
- seen("ForStatementBody", DirectParserASTType.END, {"token": token});
+ DirectParserASTContentForStatementBodyEnd data =
+ new DirectParserASTContentForStatementBodyEnd(DirectParserASTType.END,
+ token: token);
+ seen(data);
}
void handleForInLoopParts(Token awaitToken, Token forToken,
Token leftParenthesis, Token inKeyword) {
- seen("ForInLoopParts", DirectParserASTType.HANDLE, {
- "awaitToken": awaitToken,
- "forToken": forToken,
- "leftParenthesis": leftParenthesis,
- "inKeyword": inKeyword
- });
+ DirectParserASTContentForInLoopPartsHandle data =
+ new DirectParserASTContentForInLoopPartsHandle(
+ DirectParserASTType.HANDLE,
+ awaitToken: awaitToken,
+ forToken: forToken,
+ leftParenthesis: leftParenthesis,
+ inKeyword: inKeyword);
+ seen(data);
}
void endForIn(Token endToken) {
- seen("ForIn", DirectParserASTType.END, {"endToken": endToken});
+ DirectParserASTContentForInEnd data = new DirectParserASTContentForInEnd(
+ DirectParserASTType.END,
+ endToken: endToken);
+ seen(data);
}
void beginForInExpression(Token token) {
- seen("ForInExpression", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentForInExpressionBegin data =
+ new DirectParserASTContentForInExpressionBegin(
+ DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void endForInExpression(Token token) {
- seen("ForInExpression", DirectParserASTType.END, {"token": token});
+ DirectParserASTContentForInExpressionEnd data =
+ new DirectParserASTContentForInExpressionEnd(DirectParserASTType.END,
+ token: token);
+ seen(data);
}
void beginForInBody(Token token) {
- seen("ForInBody", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentForInBodyBegin data =
+ new DirectParserASTContentForInBodyBegin(DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void endForInBody(Token token) {
- seen("ForInBody", DirectParserASTType.END, {"token": token});
+ DirectParserASTContentForInBodyEnd data =
+ new DirectParserASTContentForInBodyEnd(DirectParserASTType.END,
+ token: token);
+ seen(data);
}
void beginNamedFunctionExpression(Token token) {
- seen(
- "NamedFunctionExpression", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentNamedFunctionExpressionBegin data =
+ new DirectParserASTContentNamedFunctionExpressionBegin(
+ DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void endNamedFunctionExpression(Token endToken) {
- seen("NamedFunctionExpression", DirectParserASTType.END,
- {"endToken": endToken});
+ DirectParserASTContentNamedFunctionExpressionEnd data =
+ new DirectParserASTContentNamedFunctionExpressionEnd(
+ DirectParserASTType.END,
+ endToken: endToken);
+ seen(data);
}
void beginLocalFunctionDeclaration(Token token) {
- seen("LocalFunctionDeclaration", DirectParserASTType.BEGIN,
- {"token": token});
+ DirectParserASTContentLocalFunctionDeclarationBegin data =
+ new DirectParserASTContentLocalFunctionDeclarationBegin(
+ DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void endLocalFunctionDeclaration(Token endToken) {
- seen("LocalFunctionDeclaration", DirectParserASTType.END,
- {"endToken": endToken});
+ DirectParserASTContentLocalFunctionDeclarationEnd data =
+ new DirectParserASTContentLocalFunctionDeclarationEnd(
+ DirectParserASTType.END,
+ endToken: endToken);
+ seen(data);
}
void beginBlockFunctionBody(Token token) {
- seen("BlockFunctionBody", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentBlockFunctionBodyBegin data =
+ new DirectParserASTContentBlockFunctionBodyBegin(
+ DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void endBlockFunctionBody(int count, Token beginToken, Token endToken) {
- seen("BlockFunctionBody", DirectParserASTType.END,
- {"count": count, "beginToken": beginToken, "endToken": endToken});
+ DirectParserASTContentBlockFunctionBodyEnd data =
+ new DirectParserASTContentBlockFunctionBodyEnd(DirectParserASTType.END,
+ count: count, beginToken: beginToken, endToken: endToken);
+ seen(data);
}
void handleNoFunctionBody(Token token) {
- seen("NoFunctionBody", DirectParserASTType.HANDLE, {"token": token});
+ DirectParserASTContentNoFunctionBodyHandle data =
+ new DirectParserASTContentNoFunctionBodyHandle(
+ DirectParserASTType.HANDLE,
+ token: token);
+ seen(data);
}
void handleFunctionBodySkipped(Token token, bool isExpressionBody) {
- seen("FunctionBodySkipped", DirectParserASTType.HANDLE,
- {"token": token, "isExpressionBody": isExpressionBody});
+ DirectParserASTContentFunctionBodySkippedHandle data =
+ new DirectParserASTContentFunctionBodySkippedHandle(
+ DirectParserASTType.HANDLE,
+ token: token,
+ isExpressionBody: isExpressionBody);
+ seen(data);
}
void beginFunctionName(Token token) {
- seen("FunctionName", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentFunctionNameBegin data =
+ new DirectParserASTContentFunctionNameBegin(DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void endFunctionName(Token beginToken, Token token) {
- seen("FunctionName", DirectParserASTType.END,
- {"beginToken": beginToken, "token": token});
+ DirectParserASTContentFunctionNameEnd data =
+ new DirectParserASTContentFunctionNameEnd(DirectParserASTType.END,
+ beginToken: beginToken, token: token);
+ seen(data);
}
void beginFunctionTypeAlias(Token token) {
- seen("FunctionTypeAlias", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentFunctionTypeAliasBegin data =
+ new DirectParserASTContentFunctionTypeAliasBegin(
+ DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void endFunctionTypeAlias(
Token typedefKeyword, Token equals, Token endToken) {
- seen("FunctionTypeAlias", DirectParserASTType.END, {
- "typedefKeyword": typedefKeyword,
- "equals": equals,
- "endToken": endToken
- });
+ DirectParserASTContentFunctionTypeAliasEnd data =
+ new DirectParserASTContentFunctionTypeAliasEnd(DirectParserASTType.END,
+ typedefKeyword: typedefKeyword, equals: equals, endToken: endToken);
+ seen(data);
}
void handleClassWithClause(Token withKeyword) {
- seen("ClassWithClause", DirectParserASTType.HANDLE,
- {"withKeyword": withKeyword});
+ DirectParserASTContentClassWithClauseHandle data =
+ new DirectParserASTContentClassWithClauseHandle(
+ DirectParserASTType.HANDLE,
+ withKeyword: withKeyword);
+ seen(data);
}
void handleClassNoWithClause() {
- seen("ClassNoWithClause", DirectParserASTType.HANDLE, {});
+ DirectParserASTContentClassNoWithClauseHandle data =
+ new DirectParserASTContentClassNoWithClauseHandle(
+ DirectParserASTType.HANDLE);
+ seen(data);
}
void beginNamedMixinApplication(
Token begin, Token abstractToken, Token name) {
- seen("NamedMixinApplication", DirectParserASTType.BEGIN,
- {"begin": begin, "abstractToken": abstractToken, "name": name});
+ DirectParserASTContentNamedMixinApplicationBegin data =
+ new DirectParserASTContentNamedMixinApplicationBegin(
+ DirectParserASTType.BEGIN,
+ begin: begin,
+ abstractToken: abstractToken,
+ name: name);
+ seen(data);
}
void handleNamedMixinApplicationWithClause(Token withKeyword) {
- seen("NamedMixinApplicationWithClause", DirectParserASTType.HANDLE,
- {"withKeyword": withKeyword});
+ DirectParserASTContentNamedMixinApplicationWithClauseHandle data =
+ new DirectParserASTContentNamedMixinApplicationWithClauseHandle(
+ DirectParserASTType.HANDLE,
+ withKeyword: withKeyword);
+ seen(data);
}
void endNamedMixinApplication(Token begin, Token classKeyword, Token equals,
Token implementsKeyword, Token endToken) {
- seen("NamedMixinApplication", DirectParserASTType.END, {
- "begin": begin,
- "classKeyword": classKeyword,
- "equals": equals,
- "implementsKeyword": implementsKeyword,
- "endToken": endToken
- });
+ DirectParserASTContentNamedMixinApplicationEnd data =
+ new DirectParserASTContentNamedMixinApplicationEnd(
+ DirectParserASTType.END,
+ begin: begin,
+ classKeyword: classKeyword,
+ equals: equals,
+ implementsKeyword: implementsKeyword,
+ endToken: endToken);
+ seen(data);
}
void beginHide(Token hideKeyword) {
- seen("Hide", DirectParserASTType.BEGIN, {"hideKeyword": hideKeyword});
+ DirectParserASTContentHideBegin data = new DirectParserASTContentHideBegin(
+ DirectParserASTType.BEGIN,
+ hideKeyword: hideKeyword);
+ seen(data);
}
void endHide(Token hideKeyword) {
- seen("Hide", DirectParserASTType.END, {"hideKeyword": hideKeyword});
+ DirectParserASTContentHideEnd data = new DirectParserASTContentHideEnd(
+ DirectParserASTType.END,
+ hideKeyword: hideKeyword);
+ seen(data);
}
void handleIdentifierList(int count) {
- seen("IdentifierList", DirectParserASTType.HANDLE, {"count": count});
+ DirectParserASTContentIdentifierListHandle data =
+ new DirectParserASTContentIdentifierListHandle(
+ DirectParserASTType.HANDLE,
+ count: count);
+ seen(data);
}
void beginTypeList(Token token) {
- seen("TypeList", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentTypeListBegin data =
+ new DirectParserASTContentTypeListBegin(DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void endTypeList(int count) {
- seen("TypeList", DirectParserASTType.END, {"count": count});
+ DirectParserASTContentTypeListEnd data =
+ new DirectParserASTContentTypeListEnd(DirectParserASTType.END,
+ count: count);
+ seen(data);
}
void beginIfStatement(Token token) {
- seen("IfStatement", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentIfStatementBegin data =
+ new DirectParserASTContentIfStatementBegin(DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void endIfStatement(Token ifToken, Token elseToken) {
- seen("IfStatement", DirectParserASTType.END,
- {"ifToken": ifToken, "elseToken": elseToken});
+ DirectParserASTContentIfStatementEnd data =
+ new DirectParserASTContentIfStatementEnd(DirectParserASTType.END,
+ ifToken: ifToken, elseToken: elseToken);
+ seen(data);
}
void beginThenStatement(Token token) {
- seen("ThenStatement", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentThenStatementBegin data =
+ new DirectParserASTContentThenStatementBegin(DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void endThenStatement(Token token) {
- seen("ThenStatement", DirectParserASTType.END, {"token": token});
+ DirectParserASTContentThenStatementEnd data =
+ new DirectParserASTContentThenStatementEnd(DirectParserASTType.END,
+ token: token);
+ seen(data);
}
void beginElseStatement(Token token) {
- seen("ElseStatement", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentElseStatementBegin data =
+ new DirectParserASTContentElseStatementBegin(DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void endElseStatement(Token token) {
- seen("ElseStatement", DirectParserASTType.END, {"token": token});
+ DirectParserASTContentElseStatementEnd data =
+ new DirectParserASTContentElseStatementEnd(DirectParserASTType.END,
+ token: token);
+ seen(data);
}
void beginImport(Token importKeyword) {
- seen("Import", DirectParserASTType.BEGIN, {"importKeyword": importKeyword});
+ DirectParserASTContentImportBegin data =
+ new DirectParserASTContentImportBegin(DirectParserASTType.BEGIN,
+ importKeyword: importKeyword);
+ seen(data);
}
void handleImportPrefix(Token deferredKeyword, Token asKeyword) {
- seen("ImportPrefix", DirectParserASTType.HANDLE,
- {"deferredKeyword": deferredKeyword, "asKeyword": asKeyword});
+ DirectParserASTContentImportPrefixHandle data =
+ new DirectParserASTContentImportPrefixHandle(DirectParserASTType.HANDLE,
+ deferredKeyword: deferredKeyword, asKeyword: asKeyword);
+ seen(data);
}
void endImport(Token importKeyword, Token semicolon) {
- seen("Import", DirectParserASTType.END,
- {"importKeyword": importKeyword, "semicolon": semicolon});
+ DirectParserASTContentImportEnd data = new DirectParserASTContentImportEnd(
+ DirectParserASTType.END,
+ importKeyword: importKeyword,
+ semicolon: semicolon);
+ seen(data);
}
void handleRecoverImport(Token semicolon) {
- seen("RecoverImport", DirectParserASTType.HANDLE, {"semicolon": semicolon});
+ DirectParserASTContentRecoverImportHandle data =
+ new DirectParserASTContentRecoverImportHandle(
+ DirectParserASTType.HANDLE,
+ semicolon: semicolon);
+ seen(data);
}
void beginConditionalUris(Token token) {
- seen("ConditionalUris", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentConditionalUrisBegin data =
+ new DirectParserASTContentConditionalUrisBegin(
+ DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void endConditionalUris(int count) {
- seen("ConditionalUris", DirectParserASTType.END, {"count": count});
+ DirectParserASTContentConditionalUrisEnd data =
+ new DirectParserASTContentConditionalUrisEnd(DirectParserASTType.END,
+ count: count);
+ seen(data);
}
void beginConditionalUri(Token ifKeyword) {
- seen("ConditionalUri", DirectParserASTType.BEGIN, {"ifKeyword": ifKeyword});
+ DirectParserASTContentConditionalUriBegin data =
+ new DirectParserASTContentConditionalUriBegin(DirectParserASTType.BEGIN,
+ ifKeyword: ifKeyword);
+ seen(data);
}
void endConditionalUri(Token ifKeyword, Token leftParen, Token equalSign) {
- seen("ConditionalUri", DirectParserASTType.END, {
- "ifKeyword": ifKeyword,
- "leftParen": leftParen,
- "equalSign": equalSign
- });
+ DirectParserASTContentConditionalUriEnd data =
+ new DirectParserASTContentConditionalUriEnd(DirectParserASTType.END,
+ ifKeyword: ifKeyword, leftParen: leftParen, equalSign: equalSign);
+ seen(data);
}
void handleDottedName(int count, Token firstIdentifier) {
- seen("DottedName", DirectParserASTType.HANDLE,
- {"count": count, "firstIdentifier": firstIdentifier});
+ DirectParserASTContentDottedNameHandle data =
+ new DirectParserASTContentDottedNameHandle(DirectParserASTType.HANDLE,
+ count: count, firstIdentifier: firstIdentifier);
+ seen(data);
}
void beginImplicitCreationExpression(Token token) {
- seen("ImplicitCreationExpression", DirectParserASTType.BEGIN,
- {"token": token});
+ DirectParserASTContentImplicitCreationExpressionBegin data =
+ new DirectParserASTContentImplicitCreationExpressionBegin(
+ DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void endImplicitCreationExpression(Token token) {
- seen("ImplicitCreationExpression", DirectParserASTType.END,
- {"token": token});
+ DirectParserASTContentImplicitCreationExpressionEnd data =
+ new DirectParserASTContentImplicitCreationExpressionEnd(
+ DirectParserASTType.END,
+ token: token);
+ seen(data);
}
void beginInitializedIdentifier(Token token) {
- seen("InitializedIdentifier", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentInitializedIdentifierBegin data =
+ new DirectParserASTContentInitializedIdentifierBegin(
+ DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void endInitializedIdentifier(Token nameToken) {
- seen("InitializedIdentifier", DirectParserASTType.END,
- {"nameToken": nameToken});
+ DirectParserASTContentInitializedIdentifierEnd data =
+ new DirectParserASTContentInitializedIdentifierEnd(
+ DirectParserASTType.END,
+ nameToken: nameToken);
+ seen(data);
}
void beginFieldInitializer(Token token) {
- seen("FieldInitializer", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentFieldInitializerBegin data =
+ new DirectParserASTContentFieldInitializerBegin(
+ DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void endFieldInitializer(Token assignment, Token token) {
- seen("FieldInitializer", DirectParserASTType.END,
- {"assignment": assignment, "token": token});
+ DirectParserASTContentFieldInitializerEnd data =
+ new DirectParserASTContentFieldInitializerEnd(DirectParserASTType.END,
+ assignment: assignment, token: token);
+ seen(data);
}
void handleNoFieldInitializer(Token token) {
- seen("NoFieldInitializer", DirectParserASTType.HANDLE, {"token": token});
+ DirectParserASTContentNoFieldInitializerHandle data =
+ new DirectParserASTContentNoFieldInitializerHandle(
+ DirectParserASTType.HANDLE,
+ token: token);
+ seen(data);
}
void beginVariableInitializer(Token token) {
- seen("VariableInitializer", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentVariableInitializerBegin data =
+ new DirectParserASTContentVariableInitializerBegin(
+ DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void endVariableInitializer(Token assignmentOperator) {
- seen("VariableInitializer", DirectParserASTType.END,
- {"assignmentOperator": assignmentOperator});
+ DirectParserASTContentVariableInitializerEnd data =
+ new DirectParserASTContentVariableInitializerEnd(
+ DirectParserASTType.END,
+ assignmentOperator: assignmentOperator);
+ seen(data);
}
void handleNoVariableInitializer(Token token) {
- seen("NoVariableInitializer", DirectParserASTType.HANDLE, {"token": token});
+ DirectParserASTContentNoVariableInitializerHandle data =
+ new DirectParserASTContentNoVariableInitializerHandle(
+ DirectParserASTType.HANDLE,
+ token: token);
+ seen(data);
}
void beginInitializer(Token token) {
- seen("Initializer", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentInitializerBegin data =
+ new DirectParserASTContentInitializerBegin(DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void endInitializer(Token token) {
- seen("Initializer", DirectParserASTType.END, {"token": token});
+ DirectParserASTContentInitializerEnd data =
+ new DirectParserASTContentInitializerEnd(DirectParserASTType.END,
+ token: token);
+ seen(data);
}
void beginInitializers(Token token) {
- seen("Initializers", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentInitializersBegin data =
+ new DirectParserASTContentInitializersBegin(DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void endInitializers(int count, Token beginToken, Token endToken) {
- seen("Initializers", DirectParserASTType.END,
- {"count": count, "beginToken": beginToken, "endToken": endToken});
+ DirectParserASTContentInitializersEnd data =
+ new DirectParserASTContentInitializersEnd(DirectParserASTType.END,
+ count: count, beginToken: beginToken, endToken: endToken);
+ seen(data);
}
void handleNoInitializers() {
- seen("NoInitializers", DirectParserASTType.HANDLE, {});
+ DirectParserASTContentNoInitializersHandle data =
+ new DirectParserASTContentNoInitializersHandle(
+ DirectParserASTType.HANDLE);
+ seen(data);
}
void handleInvalidExpression(Token token) {
- seen("InvalidExpression", DirectParserASTType.HANDLE, {"token": token});
+ DirectParserASTContentInvalidExpressionHandle data =
+ new DirectParserASTContentInvalidExpressionHandle(
+ DirectParserASTType.HANDLE,
+ token: token);
+ seen(data);
}
void handleInvalidFunctionBody(Token token) {
- seen("InvalidFunctionBody", DirectParserASTType.HANDLE, {"token": token});
+ DirectParserASTContentInvalidFunctionBodyHandle data =
+ new DirectParserASTContentInvalidFunctionBodyHandle(
+ DirectParserASTType.HANDLE,
+ token: token);
+ seen(data);
}
void handleInvalidTypeReference(Token token) {
- seen("InvalidTypeReference", DirectParserASTType.HANDLE, {"token": token});
+ DirectParserASTContentInvalidTypeReferenceHandle data =
+ new DirectParserASTContentInvalidTypeReferenceHandle(
+ DirectParserASTType.HANDLE,
+ token: token);
+ seen(data);
}
void handleLabel(Token token) {
- seen("Label", DirectParserASTType.HANDLE, {"token": token});
+ DirectParserASTContentLabelHandle data =
+ new DirectParserASTContentLabelHandle(DirectParserASTType.HANDLE,
+ token: token);
+ seen(data);
}
void beginLabeledStatement(Token token, int labelCount) {
- seen("LabeledStatement", DirectParserASTType.BEGIN,
- {"token": token, "labelCount": labelCount});
+ DirectParserASTContentLabeledStatementBegin data =
+ new DirectParserASTContentLabeledStatementBegin(
+ DirectParserASTType.BEGIN,
+ token: token,
+ labelCount: labelCount);
+ seen(data);
}
void endLabeledStatement(int labelCount) {
- seen("LabeledStatement", DirectParserASTType.END,
- {"labelCount": labelCount});
+ DirectParserASTContentLabeledStatementEnd data =
+ new DirectParserASTContentLabeledStatementEnd(DirectParserASTType.END,
+ labelCount: labelCount);
+ seen(data);
}
void beginLibraryName(Token token) {
- seen("LibraryName", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentLibraryNameBegin data =
+ new DirectParserASTContentLibraryNameBegin(DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void endLibraryName(Token libraryKeyword, Token semicolon) {
- seen("LibraryName", DirectParserASTType.END,
- {"libraryKeyword": libraryKeyword, "semicolon": semicolon});
+ DirectParserASTContentLibraryNameEnd data =
+ new DirectParserASTContentLibraryNameEnd(DirectParserASTType.END,
+ libraryKeyword: libraryKeyword, semicolon: semicolon);
+ seen(data);
}
void handleLiteralMapEntry(Token colon, Token endToken) {
- seen("LiteralMapEntry", DirectParserASTType.HANDLE,
- {"colon": colon, "endToken": endToken});
+ DirectParserASTContentLiteralMapEntryHandle data =
+ new DirectParserASTContentLiteralMapEntryHandle(
+ DirectParserASTType.HANDLE,
+ colon: colon,
+ endToken: endToken);
+ seen(data);
}
void beginLiteralString(Token token) {
- seen("LiteralString", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentLiteralStringBegin data =
+ new DirectParserASTContentLiteralStringBegin(DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void handleInterpolationExpression(Token leftBracket, Token rightBracket) {
- seen("InterpolationExpression", DirectParserASTType.HANDLE,
- {"leftBracket": leftBracket, "rightBracket": rightBracket});
+ DirectParserASTContentInterpolationExpressionHandle data =
+ new DirectParserASTContentInterpolationExpressionHandle(
+ DirectParserASTType.HANDLE,
+ leftBracket: leftBracket,
+ rightBracket: rightBracket);
+ seen(data);
}
void endLiteralString(int interpolationCount, Token endToken) {
- seen("LiteralString", DirectParserASTType.END,
- {"interpolationCount": interpolationCount, "endToken": endToken});
+ DirectParserASTContentLiteralStringEnd data =
+ new DirectParserASTContentLiteralStringEnd(DirectParserASTType.END,
+ interpolationCount: interpolationCount, endToken: endToken);
+ seen(data);
}
void handleStringJuxtaposition(Token startToken, int literalCount) {
- seen("StringJuxtaposition", DirectParserASTType.HANDLE,
- {"startToken": startToken, "literalCount": literalCount});
+ DirectParserASTContentStringJuxtapositionHandle data =
+ new DirectParserASTContentStringJuxtapositionHandle(
+ DirectParserASTType.HANDLE,
+ startToken: startToken,
+ literalCount: literalCount);
+ seen(data);
}
void beginMember() {
- seen("Member", DirectParserASTType.BEGIN, {});
+ DirectParserASTContentMemberBegin data =
+ new DirectParserASTContentMemberBegin(DirectParserASTType.BEGIN);
+ seen(data);
}
void handleInvalidMember(Token endToken) {
- seen("InvalidMember", DirectParserASTType.HANDLE, {"endToken": endToken});
+ DirectParserASTContentInvalidMemberHandle data =
+ new DirectParserASTContentInvalidMemberHandle(
+ DirectParserASTType.HANDLE,
+ endToken: endToken);
+ seen(data);
}
void endMember() {
- seen("Member", DirectParserASTType.END, {});
+ DirectParserASTContentMemberEnd data =
+ new DirectParserASTContentMemberEnd(DirectParserASTType.END);
+ seen(data);
}
void beginMethod(Token externalToken, Token staticToken, Token covariantToken,
Token varFinalOrConst, Token getOrSet, Token name) {
- seen("Method", DirectParserASTType.BEGIN, {
- "externalToken": externalToken,
- "staticToken": staticToken,
- "covariantToken": covariantToken,
- "varFinalOrConst": varFinalOrConst,
- "getOrSet": getOrSet,
- "name": name
- });
+ DirectParserASTContentMethodBegin data =
+ new DirectParserASTContentMethodBegin(DirectParserASTType.BEGIN,
+ externalToken: externalToken,
+ staticToken: staticToken,
+ covariantToken: covariantToken,
+ varFinalOrConst: varFinalOrConst,
+ getOrSet: getOrSet,
+ name: name);
+ seen(data);
}
void endClassMethod(Token getOrSet, Token beginToken, Token beginParam,
Token beginInitializers, Token endToken) {
- seen("ClassMethod", DirectParserASTType.END, {
- "getOrSet": getOrSet,
- "beginToken": beginToken,
- "beginParam": beginParam,
- "beginInitializers": beginInitializers,
- "endToken": endToken
- });
+ DirectParserASTContentClassMethodEnd data =
+ new DirectParserASTContentClassMethodEnd(DirectParserASTType.END,
+ getOrSet: getOrSet,
+ beginToken: beginToken,
+ beginParam: beginParam,
+ beginInitializers: beginInitializers,
+ endToken: endToken);
+ seen(data);
}
void endMixinMethod(Token getOrSet, Token beginToken, Token beginParam,
Token beginInitializers, Token endToken) {
- seen("MixinMethod", DirectParserASTType.END, {
- "getOrSet": getOrSet,
- "beginToken": beginToken,
- "beginParam": beginParam,
- "beginInitializers": beginInitializers,
- "endToken": endToken
- });
+ DirectParserASTContentMixinMethodEnd data =
+ new DirectParserASTContentMixinMethodEnd(DirectParserASTType.END,
+ getOrSet: getOrSet,
+ beginToken: beginToken,
+ beginParam: beginParam,
+ beginInitializers: beginInitializers,
+ endToken: endToken);
+ seen(data);
}
void endExtensionMethod(Token getOrSet, Token beginToken, Token beginParam,
Token beginInitializers, Token endToken) {
- seen("ExtensionMethod", DirectParserASTType.END, {
- "getOrSet": getOrSet,
- "beginToken": beginToken,
- "beginParam": beginParam,
- "beginInitializers": beginInitializers,
- "endToken": endToken
- });
+ DirectParserASTContentExtensionMethodEnd data =
+ new DirectParserASTContentExtensionMethodEnd(DirectParserASTType.END,
+ getOrSet: getOrSet,
+ beginToken: beginToken,
+ beginParam: beginParam,
+ beginInitializers: beginInitializers,
+ endToken: endToken);
+ seen(data);
}
void endClassConstructor(Token getOrSet, Token beginToken, Token beginParam,
Token beginInitializers, Token endToken) {
- seen("ClassConstructor", DirectParserASTType.END, {
- "getOrSet": getOrSet,
- "beginToken": beginToken,
- "beginParam": beginParam,
- "beginInitializers": beginInitializers,
- "endToken": endToken
- });
+ DirectParserASTContentClassConstructorEnd data =
+ new DirectParserASTContentClassConstructorEnd(DirectParserASTType.END,
+ getOrSet: getOrSet,
+ beginToken: beginToken,
+ beginParam: beginParam,
+ beginInitializers: beginInitializers,
+ endToken: endToken);
+ seen(data);
}
void endMixinConstructor(Token getOrSet, Token beginToken, Token beginParam,
Token beginInitializers, Token endToken) {
- seen("MixinConstructor", DirectParserASTType.END, {
- "getOrSet": getOrSet,
- "beginToken": beginToken,
- "beginParam": beginParam,
- "beginInitializers": beginInitializers,
- "endToken": endToken
- });
+ DirectParserASTContentMixinConstructorEnd data =
+ new DirectParserASTContentMixinConstructorEnd(DirectParserASTType.END,
+ getOrSet: getOrSet,
+ beginToken: beginToken,
+ beginParam: beginParam,
+ beginInitializers: beginInitializers,
+ endToken: endToken);
+ seen(data);
}
void endExtensionConstructor(Token getOrSet, Token beginToken,
Token beginParam, Token beginInitializers, Token endToken) {
- seen("ExtensionConstructor", DirectParserASTType.END, {
- "getOrSet": getOrSet,
- "beginToken": beginToken,
- "beginParam": beginParam,
- "beginInitializers": beginInitializers,
- "endToken": endToken
- });
+ DirectParserASTContentExtensionConstructorEnd data =
+ new DirectParserASTContentExtensionConstructorEnd(
+ DirectParserASTType.END,
+ getOrSet: getOrSet,
+ beginToken: beginToken,
+ beginParam: beginParam,
+ beginInitializers: beginInitializers,
+ endToken: endToken);
+ seen(data);
}
void beginMetadataStar(Token token) {
- seen("MetadataStar", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentMetadataStarBegin data =
+ new DirectParserASTContentMetadataStarBegin(DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void endMetadataStar(int count) {
- seen("MetadataStar", DirectParserASTType.END, {"count": count});
+ DirectParserASTContentMetadataStarEnd data =
+ new DirectParserASTContentMetadataStarEnd(DirectParserASTType.END,
+ count: count);
+ seen(data);
}
void beginMetadata(Token token) {
- seen("Metadata", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentMetadataBegin data =
+ new DirectParserASTContentMetadataBegin(DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void endMetadata(Token beginToken, Token periodBeforeName, Token endToken) {
- seen("Metadata", DirectParserASTType.END, {
- "beginToken": beginToken,
- "periodBeforeName": periodBeforeName,
- "endToken": endToken
- });
+ DirectParserASTContentMetadataEnd data =
+ new DirectParserASTContentMetadataEnd(DirectParserASTType.END,
+ beginToken: beginToken,
+ periodBeforeName: periodBeforeName,
+ endToken: endToken);
+ seen(data);
}
void beginOptionalFormalParameters(Token token) {
- seen("OptionalFormalParameters", DirectParserASTType.BEGIN,
- {"token": token});
+ DirectParserASTContentOptionalFormalParametersBegin data =
+ new DirectParserASTContentOptionalFormalParametersBegin(
+ DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void endOptionalFormalParameters(
int count, Token beginToken, Token endToken) {
- seen("OptionalFormalParameters", DirectParserASTType.END,
- {"count": count, "beginToken": beginToken, "endToken": endToken});
+ DirectParserASTContentOptionalFormalParametersEnd data =
+ new DirectParserASTContentOptionalFormalParametersEnd(
+ DirectParserASTType.END,
+ count: count,
+ beginToken: beginToken,
+ endToken: endToken);
+ seen(data);
}
void beginPart(Token token) {
- seen("Part", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentPartBegin data = new DirectParserASTContentPartBegin(
+ DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void endPart(Token partKeyword, Token semicolon) {
- seen("Part", DirectParserASTType.END,
- {"partKeyword": partKeyword, "semicolon": semicolon});
+ DirectParserASTContentPartEnd data = new DirectParserASTContentPartEnd(
+ DirectParserASTType.END,
+ partKeyword: partKeyword,
+ semicolon: semicolon);
+ seen(data);
}
void beginPartOf(Token token) {
- seen("PartOf", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentPartOfBegin data =
+ new DirectParserASTContentPartOfBegin(DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void endPartOf(
Token partKeyword, Token ofKeyword, Token semicolon, bool hasName) {
- seen("PartOf", DirectParserASTType.END, {
- "partKeyword": partKeyword,
- "ofKeyword": ofKeyword,
- "semicolon": semicolon,
- "hasName": hasName
- });
+ DirectParserASTContentPartOfEnd data = new DirectParserASTContentPartOfEnd(
+ DirectParserASTType.END,
+ partKeyword: partKeyword,
+ ofKeyword: ofKeyword,
+ semicolon: semicolon,
+ hasName: hasName);
+ seen(data);
}
void beginRedirectingFactoryBody(Token token) {
- seen("RedirectingFactoryBody", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentRedirectingFactoryBodyBegin data =
+ new DirectParserASTContentRedirectingFactoryBodyBegin(
+ DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void endRedirectingFactoryBody(Token beginToken, Token endToken) {
- seen("RedirectingFactoryBody", DirectParserASTType.END,
- {"beginToken": beginToken, "endToken": endToken});
+ DirectParserASTContentRedirectingFactoryBodyEnd data =
+ new DirectParserASTContentRedirectingFactoryBodyEnd(
+ DirectParserASTType.END,
+ beginToken: beginToken,
+ endToken: endToken);
+ seen(data);
}
void beginReturnStatement(Token token) {
- seen("ReturnStatement", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentReturnStatementBegin data =
+ new DirectParserASTContentReturnStatementBegin(
+ DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void handleNativeFunctionBody(Token nativeToken, Token semicolon) {
- seen("NativeFunctionBody", DirectParserASTType.HANDLE,
- {"nativeToken": nativeToken, "semicolon": semicolon});
+ DirectParserASTContentNativeFunctionBodyHandle data =
+ new DirectParserASTContentNativeFunctionBodyHandle(
+ DirectParserASTType.HANDLE,
+ nativeToken: nativeToken,
+ semicolon: semicolon);
+ seen(data);
}
void handleNativeFunctionBodyIgnored(Token nativeToken, Token semicolon) {
- seen("NativeFunctionBodyIgnored", DirectParserASTType.HANDLE,
- {"nativeToken": nativeToken, "semicolon": semicolon});
+ DirectParserASTContentNativeFunctionBodyIgnoredHandle data =
+ new DirectParserASTContentNativeFunctionBodyIgnoredHandle(
+ DirectParserASTType.HANDLE,
+ nativeToken: nativeToken,
+ semicolon: semicolon);
+ seen(data);
}
void handleNativeFunctionBodySkipped(Token nativeToken, Token semicolon) {
- seen("NativeFunctionBodySkipped", DirectParserASTType.HANDLE,
- {"nativeToken": nativeToken, "semicolon": semicolon});
+ DirectParserASTContentNativeFunctionBodySkippedHandle data =
+ new DirectParserASTContentNativeFunctionBodySkippedHandle(
+ DirectParserASTType.HANDLE,
+ nativeToken: nativeToken,
+ semicolon: semicolon);
+ seen(data);
}
void handleEmptyFunctionBody(Token semicolon) {
- seen("EmptyFunctionBody", DirectParserASTType.HANDLE,
- {"semicolon": semicolon});
+ DirectParserASTContentEmptyFunctionBodyHandle data =
+ new DirectParserASTContentEmptyFunctionBodyHandle(
+ DirectParserASTType.HANDLE,
+ semicolon: semicolon);
+ seen(data);
}
void handleExpressionFunctionBody(Token arrowToken, Token endToken) {
- seen("ExpressionFunctionBody", DirectParserASTType.HANDLE,
- {"arrowToken": arrowToken, "endToken": endToken});
+ DirectParserASTContentExpressionFunctionBodyHandle data =
+ new DirectParserASTContentExpressionFunctionBodyHandle(
+ DirectParserASTType.HANDLE,
+ arrowToken: arrowToken,
+ endToken: endToken);
+ seen(data);
}
void endReturnStatement(
bool hasExpression, Token beginToken, Token endToken) {
- seen("ReturnStatement", DirectParserASTType.END, {
- "hasExpression": hasExpression,
- "beginToken": beginToken,
- "endToken": endToken
- });
+ DirectParserASTContentReturnStatementEnd data =
+ new DirectParserASTContentReturnStatementEnd(DirectParserASTType.END,
+ hasExpression: hasExpression,
+ beginToken: beginToken,
+ endToken: endToken);
+ seen(data);
}
void handleSend(Token beginToken, Token endToken) {
- seen("Send", DirectParserASTType.HANDLE,
- {"beginToken": beginToken, "endToken": endToken});
+ DirectParserASTContentSendHandle data =
+ new DirectParserASTContentSendHandle(DirectParserASTType.HANDLE,
+ beginToken: beginToken, endToken: endToken);
+ seen(data);
}
void beginShow(Token showKeyword) {
- seen("Show", DirectParserASTType.BEGIN, {"showKeyword": showKeyword});
+ DirectParserASTContentShowBegin data = new DirectParserASTContentShowBegin(
+ DirectParserASTType.BEGIN,
+ showKeyword: showKeyword);
+ seen(data);
}
void endShow(Token showKeyword) {
- seen("Show", DirectParserASTType.END, {"showKeyword": showKeyword});
+ DirectParserASTContentShowEnd data = new DirectParserASTContentShowEnd(
+ DirectParserASTType.END,
+ showKeyword: showKeyword);
+ seen(data);
}
void beginSwitchStatement(Token token) {
- seen("SwitchStatement", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentSwitchStatementBegin data =
+ new DirectParserASTContentSwitchStatementBegin(
+ DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void endSwitchStatement(Token switchKeyword, Token endToken) {
- seen("SwitchStatement", DirectParserASTType.END,
- {"switchKeyword": switchKeyword, "endToken": endToken});
+ DirectParserASTContentSwitchStatementEnd data =
+ new DirectParserASTContentSwitchStatementEnd(DirectParserASTType.END,
+ switchKeyword: switchKeyword, endToken: endToken);
+ seen(data);
}
void beginSwitchBlock(Token token) {
- seen("SwitchBlock", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentSwitchBlockBegin data =
+ new DirectParserASTContentSwitchBlockBegin(DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void endSwitchBlock(int caseCount, Token beginToken, Token endToken) {
- seen("SwitchBlock", DirectParserASTType.END, {
- "caseCount": caseCount,
- "beginToken": beginToken,
- "endToken": endToken
- });
+ DirectParserASTContentSwitchBlockEnd data =
+ new DirectParserASTContentSwitchBlockEnd(DirectParserASTType.END,
+ caseCount: caseCount, beginToken: beginToken, endToken: endToken);
+ seen(data);
}
void beginLiteralSymbol(Token token) {
- seen("LiteralSymbol", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentLiteralSymbolBegin data =
+ new DirectParserASTContentLiteralSymbolBegin(DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void endLiteralSymbol(Token hashToken, int identifierCount) {
- seen("LiteralSymbol", DirectParserASTType.END,
- {"hashToken": hashToken, "identifierCount": identifierCount});
+ DirectParserASTContentLiteralSymbolEnd data =
+ new DirectParserASTContentLiteralSymbolEnd(DirectParserASTType.END,
+ hashToken: hashToken, identifierCount: identifierCount);
+ seen(data);
}
void handleThrowExpression(Token throwToken, Token endToken) {
- seen("ThrowExpression", DirectParserASTType.HANDLE,
- {"throwToken": throwToken, "endToken": endToken});
+ DirectParserASTContentThrowExpressionHandle data =
+ new DirectParserASTContentThrowExpressionHandle(
+ DirectParserASTType.HANDLE,
+ throwToken: throwToken,
+ endToken: endToken);
+ seen(data);
}
void beginRethrowStatement(Token token) {
- seen("RethrowStatement", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentRethrowStatementBegin data =
+ new DirectParserASTContentRethrowStatementBegin(
+ DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void endRethrowStatement(Token rethrowToken, Token endToken) {
- seen("RethrowStatement", DirectParserASTType.END,
- {"rethrowToken": rethrowToken, "endToken": endToken});
+ DirectParserASTContentRethrowStatementEnd data =
+ new DirectParserASTContentRethrowStatementEnd(DirectParserASTType.END,
+ rethrowToken: rethrowToken, endToken: endToken);
+ seen(data);
}
void endTopLevelDeclaration(Token nextToken) {
- seen("TopLevelDeclaration", DirectParserASTType.END,
- {"nextToken": nextToken});
+ DirectParserASTContentTopLevelDeclarationEnd data =
+ new DirectParserASTContentTopLevelDeclarationEnd(
+ DirectParserASTType.END,
+ nextToken: nextToken);
+ seen(data);
}
void handleInvalidTopLevelDeclaration(Token endToken) {
- seen("InvalidTopLevelDeclaration", DirectParserASTType.HANDLE,
- {"endToken": endToken});
+ DirectParserASTContentInvalidTopLevelDeclarationHandle data =
+ new DirectParserASTContentInvalidTopLevelDeclarationHandle(
+ DirectParserASTType.HANDLE,
+ endToken: endToken);
+ seen(data);
}
void beginTopLevelMember(Token token) {
- seen("TopLevelMember", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentTopLevelMemberBegin data =
+ new DirectParserASTContentTopLevelMemberBegin(DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void beginFields(Token lastConsumed) {
- seen("Fields", DirectParserASTType.BEGIN, {"lastConsumed": lastConsumed});
+ DirectParserASTContentFieldsBegin data =
+ new DirectParserASTContentFieldsBegin(DirectParserASTType.BEGIN,
+ lastConsumed: lastConsumed);
+ seen(data);
}
void endTopLevelFields(
@@ -1115,348 +1643,533 @@
int count,
Token beginToken,
Token endToken) {
- seen("TopLevelFields", DirectParserASTType.END, {
- "externalToken": externalToken,
- "staticToken": staticToken,
- "covariantToken": covariantToken,
- "lateToken": lateToken,
- "varFinalOrConst": varFinalOrConst,
- "count": count,
- "beginToken": beginToken,
- "endToken": endToken
- });
+ DirectParserASTContentTopLevelFieldsEnd data =
+ new DirectParserASTContentTopLevelFieldsEnd(DirectParserASTType.END,
+ externalToken: externalToken,
+ staticToken: staticToken,
+ covariantToken: covariantToken,
+ lateToken: lateToken,
+ varFinalOrConst: varFinalOrConst,
+ count: count,
+ beginToken: beginToken,
+ endToken: endToken);
+ seen(data);
}
void beginTopLevelMethod(Token lastConsumed, Token externalToken) {
- seen("TopLevelMethod", DirectParserASTType.BEGIN,
- {"lastConsumed": lastConsumed, "externalToken": externalToken});
+ DirectParserASTContentTopLevelMethodBegin data =
+ new DirectParserASTContentTopLevelMethodBegin(DirectParserASTType.BEGIN,
+ lastConsumed: lastConsumed, externalToken: externalToken);
+ seen(data);
}
void endTopLevelMethod(Token beginToken, Token getOrSet, Token endToken) {
- seen("TopLevelMethod", DirectParserASTType.END,
- {"beginToken": beginToken, "getOrSet": getOrSet, "endToken": endToken});
+ DirectParserASTContentTopLevelMethodEnd data =
+ new DirectParserASTContentTopLevelMethodEnd(DirectParserASTType.END,
+ beginToken: beginToken, getOrSet: getOrSet, endToken: endToken);
+ seen(data);
}
void beginTryStatement(Token token) {
- seen("TryStatement", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentTryStatementBegin data =
+ new DirectParserASTContentTryStatementBegin(DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void handleCaseMatch(Token caseKeyword, Token colon) {
- seen("CaseMatch", DirectParserASTType.HANDLE,
- {"caseKeyword": caseKeyword, "colon": colon});
+ DirectParserASTContentCaseMatchHandle data =
+ new DirectParserASTContentCaseMatchHandle(DirectParserASTType.HANDLE,
+ caseKeyword: caseKeyword, colon: colon);
+ seen(data);
}
void beginCatchClause(Token token) {
- seen("CatchClause", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentCatchClauseBegin data =
+ new DirectParserASTContentCatchClauseBegin(DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void endCatchClause(Token token) {
- seen("CatchClause", DirectParserASTType.END, {"token": token});
+ DirectParserASTContentCatchClauseEnd data =
+ new DirectParserASTContentCatchClauseEnd(DirectParserASTType.END,
+ token: token);
+ seen(data);
}
void handleCatchBlock(Token onKeyword, Token catchKeyword, Token comma) {
- seen("CatchBlock", DirectParserASTType.HANDLE,
- {"onKeyword": onKeyword, "catchKeyword": catchKeyword, "comma": comma});
+ DirectParserASTContentCatchBlockHandle data =
+ new DirectParserASTContentCatchBlockHandle(DirectParserASTType.HANDLE,
+ onKeyword: onKeyword, catchKeyword: catchKeyword, comma: comma);
+ seen(data);
}
void handleFinallyBlock(Token finallyKeyword) {
- seen("FinallyBlock", DirectParserASTType.HANDLE,
- {"finallyKeyword": finallyKeyword});
+ DirectParserASTContentFinallyBlockHandle data =
+ new DirectParserASTContentFinallyBlockHandle(DirectParserASTType.HANDLE,
+ finallyKeyword: finallyKeyword);
+ seen(data);
}
void endTryStatement(int catchCount, Token tryKeyword, Token finallyKeyword) {
- seen("TryStatement", DirectParserASTType.END, {
- "catchCount": catchCount,
- "tryKeyword": tryKeyword,
- "finallyKeyword": finallyKeyword
- });
+ DirectParserASTContentTryStatementEnd data =
+ new DirectParserASTContentTryStatementEnd(DirectParserASTType.END,
+ catchCount: catchCount,
+ tryKeyword: tryKeyword,
+ finallyKeyword: finallyKeyword);
+ seen(data);
}
void handleType(Token beginToken, Token questionMark) {
- seen("Type", DirectParserASTType.HANDLE,
- {"beginToken": beginToken, "questionMark": questionMark});
+ DirectParserASTContentTypeHandle data =
+ new DirectParserASTContentTypeHandle(DirectParserASTType.HANDLE,
+ beginToken: beginToken, questionMark: questionMark);
+ seen(data);
}
void handleNonNullAssertExpression(Token bang) {
- seen("NonNullAssertExpression", DirectParserASTType.HANDLE, {"bang": bang});
+ DirectParserASTContentNonNullAssertExpressionHandle data =
+ new DirectParserASTContentNonNullAssertExpressionHandle(
+ DirectParserASTType.HANDLE,
+ bang: bang);
+ seen(data);
}
void handleNoName(Token token) {
- seen("NoName", DirectParserASTType.HANDLE, {"token": token});
+ DirectParserASTContentNoNameHandle data =
+ new DirectParserASTContentNoNameHandle(DirectParserASTType.HANDLE,
+ token: token);
+ seen(data);
}
void beginFunctionType(Token beginToken) {
- seen("FunctionType", DirectParserASTType.BEGIN, {"beginToken": beginToken});
+ DirectParserASTContentFunctionTypeBegin data =
+ new DirectParserASTContentFunctionTypeBegin(DirectParserASTType.BEGIN,
+ beginToken: beginToken);
+ seen(data);
}
void endFunctionType(Token functionToken, Token questionMark) {
- seen("FunctionType", DirectParserASTType.END,
- {"functionToken": functionToken, "questionMark": questionMark});
+ DirectParserASTContentFunctionTypeEnd data =
+ new DirectParserASTContentFunctionTypeEnd(DirectParserASTType.END,
+ functionToken: functionToken, questionMark: questionMark);
+ seen(data);
}
void beginTypeArguments(Token token) {
- seen("TypeArguments", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentTypeArgumentsBegin data =
+ new DirectParserASTContentTypeArgumentsBegin(DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void endTypeArguments(int count, Token beginToken, Token endToken) {
- seen("TypeArguments", DirectParserASTType.END,
- {"count": count, "beginToken": beginToken, "endToken": endToken});
+ DirectParserASTContentTypeArgumentsEnd data =
+ new DirectParserASTContentTypeArgumentsEnd(DirectParserASTType.END,
+ count: count, beginToken: beginToken, endToken: endToken);
+ seen(data);
}
void handleInvalidTypeArguments(Token token) {
- seen("InvalidTypeArguments", DirectParserASTType.HANDLE, {"token": token});
+ DirectParserASTContentInvalidTypeArgumentsHandle data =
+ new DirectParserASTContentInvalidTypeArgumentsHandle(
+ DirectParserASTType.HANDLE,
+ token: token);
+ seen(data);
}
void handleNoTypeArguments(Token token) {
- seen("NoTypeArguments", DirectParserASTType.HANDLE, {"token": token});
+ DirectParserASTContentNoTypeArgumentsHandle data =
+ new DirectParserASTContentNoTypeArgumentsHandle(
+ DirectParserASTType.HANDLE,
+ token: token);
+ seen(data);
}
void beginTypeVariable(Token token) {
- seen("TypeVariable", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentTypeVariableBegin data =
+ new DirectParserASTContentTypeVariableBegin(DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void handleTypeVariablesDefined(Token token, int count) {
- seen("TypeVariablesDefined", DirectParserASTType.HANDLE,
- {"token": token, "count": count});
+ DirectParserASTContentTypeVariablesDefinedHandle data =
+ new DirectParserASTContentTypeVariablesDefinedHandle(
+ DirectParserASTType.HANDLE,
+ token: token,
+ count: count);
+ seen(data);
}
void endTypeVariable(
Token token, int index, Token extendsOrSuper, Token variance) {
- seen("TypeVariable", DirectParserASTType.END, {
- "token": token,
- "index": index,
- "extendsOrSuper": extendsOrSuper,
- "variance": variance
- });
+ DirectParserASTContentTypeVariableEnd data =
+ new DirectParserASTContentTypeVariableEnd(DirectParserASTType.END,
+ token: token,
+ index: index,
+ extendsOrSuper: extendsOrSuper,
+ variance: variance);
+ seen(data);
}
void beginTypeVariables(Token token) {
- seen("TypeVariables", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentTypeVariablesBegin data =
+ new DirectParserASTContentTypeVariablesBegin(DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void endTypeVariables(Token beginToken, Token endToken) {
- seen("TypeVariables", DirectParserASTType.END,
- {"beginToken": beginToken, "endToken": endToken});
+ DirectParserASTContentTypeVariablesEnd data =
+ new DirectParserASTContentTypeVariablesEnd(DirectParserASTType.END,
+ beginToken: beginToken, endToken: endToken);
+ seen(data);
}
void beginFunctionExpression(Token token) {
- seen("FunctionExpression", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentFunctionExpressionBegin data =
+ new DirectParserASTContentFunctionExpressionBegin(
+ DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void endFunctionExpression(Token beginToken, Token token) {
- seen("FunctionExpression", DirectParserASTType.END,
- {"beginToken": beginToken, "token": token});
+ DirectParserASTContentFunctionExpressionEnd data =
+ new DirectParserASTContentFunctionExpressionEnd(DirectParserASTType.END,
+ beginToken: beginToken, token: token);
+ seen(data);
}
void beginVariablesDeclaration(
Token token, Token lateToken, Token varFinalOrConst) {
- seen("VariablesDeclaration", DirectParserASTType.BEGIN, {
- "token": token,
- "lateToken": lateToken,
- "varFinalOrConst": varFinalOrConst
- });
+ DirectParserASTContentVariablesDeclarationBegin data =
+ new DirectParserASTContentVariablesDeclarationBegin(
+ DirectParserASTType.BEGIN,
+ token: token,
+ lateToken: lateToken,
+ varFinalOrConst: varFinalOrConst);
+ seen(data);
}
void endVariablesDeclaration(int count, Token endToken) {
- seen("VariablesDeclaration", DirectParserASTType.END,
- {"count": count, "endToken": endToken});
+ DirectParserASTContentVariablesDeclarationEnd data =
+ new DirectParserASTContentVariablesDeclarationEnd(
+ DirectParserASTType.END,
+ count: count,
+ endToken: endToken);
+ seen(data);
}
void beginWhileStatement(Token token) {
- seen("WhileStatement", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentWhileStatementBegin data =
+ new DirectParserASTContentWhileStatementBegin(DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void endWhileStatement(Token whileKeyword, Token endToken) {
- seen("WhileStatement", DirectParserASTType.END,
- {"whileKeyword": whileKeyword, "endToken": endToken});
+ DirectParserASTContentWhileStatementEnd data =
+ new DirectParserASTContentWhileStatementEnd(DirectParserASTType.END,
+ whileKeyword: whileKeyword, endToken: endToken);
+ seen(data);
}
void beginAsOperatorType(Token operator) {
- seen("AsOperatorType", DirectParserASTType.BEGIN, {"operator": operator});
+ DirectParserASTContentAsOperatorTypeBegin data =
+ new DirectParserASTContentAsOperatorTypeBegin(DirectParserASTType.BEGIN,
+ operator: operator);
+ seen(data);
}
void endAsOperatorType(Token operator) {
- seen("AsOperatorType", DirectParserASTType.END, {"operator": operator});
+ DirectParserASTContentAsOperatorTypeEnd data =
+ new DirectParserASTContentAsOperatorTypeEnd(DirectParserASTType.END,
+ operator: operator);
+ seen(data);
}
void handleAsOperator(Token operator) {
- seen("AsOperator", DirectParserASTType.HANDLE, {"operator": operator});
+ DirectParserASTContentAsOperatorHandle data =
+ new DirectParserASTContentAsOperatorHandle(DirectParserASTType.HANDLE,
+ operator: operator);
+ seen(data);
}
void handleAssignmentExpression(Token token) {
- seen("AssignmentExpression", DirectParserASTType.HANDLE, {"token": token});
+ DirectParserASTContentAssignmentExpressionHandle data =
+ new DirectParserASTContentAssignmentExpressionHandle(
+ DirectParserASTType.HANDLE,
+ token: token);
+ seen(data);
}
void beginBinaryExpression(Token token) {
- seen("BinaryExpression", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentBinaryExpressionBegin data =
+ new DirectParserASTContentBinaryExpressionBegin(
+ DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void endBinaryExpression(Token token) {
- seen("BinaryExpression", DirectParserASTType.END, {"token": token});
+ DirectParserASTContentBinaryExpressionEnd data =
+ new DirectParserASTContentBinaryExpressionEnd(DirectParserASTType.END,
+ token: token);
+ seen(data);
}
void handleEndingBinaryExpression(Token token) {
- seen(
- "EndingBinaryExpression", DirectParserASTType.HANDLE, {"token": token});
+ DirectParserASTContentEndingBinaryExpressionHandle data =
+ new DirectParserASTContentEndingBinaryExpressionHandle(
+ DirectParserASTType.HANDLE,
+ token: token);
+ seen(data);
}
void beginConditionalExpression(Token question) {
- seen("ConditionalExpression", DirectParserASTType.BEGIN,
- {"question": question});
+ DirectParserASTContentConditionalExpressionBegin data =
+ new DirectParserASTContentConditionalExpressionBegin(
+ DirectParserASTType.BEGIN,
+ question: question);
+ seen(data);
}
void handleConditionalExpressionColon() {
- seen("ConditionalExpressionColon", DirectParserASTType.HANDLE, {});
+ DirectParserASTContentConditionalExpressionColonHandle data =
+ new DirectParserASTContentConditionalExpressionColonHandle(
+ DirectParserASTType.HANDLE);
+ seen(data);
}
void endConditionalExpression(Token question, Token colon) {
- seen("ConditionalExpression", DirectParserASTType.END,
- {"question": question, "colon": colon});
+ DirectParserASTContentConditionalExpressionEnd data =
+ new DirectParserASTContentConditionalExpressionEnd(
+ DirectParserASTType.END,
+ question: question,
+ colon: colon);
+ seen(data);
}
void beginConstExpression(Token constKeyword) {
- seen("ConstExpression", DirectParserASTType.BEGIN,
- {"constKeyword": constKeyword});
+ DirectParserASTContentConstExpressionBegin data =
+ new DirectParserASTContentConstExpressionBegin(
+ DirectParserASTType.BEGIN,
+ constKeyword: constKeyword);
+ seen(data);
}
void endConstExpression(Token token) {
- seen("ConstExpression", DirectParserASTType.END, {"token": token});
+ DirectParserASTContentConstExpressionEnd data =
+ new DirectParserASTContentConstExpressionEnd(DirectParserASTType.END,
+ token: token);
+ seen(data);
}
void beginForControlFlow(Token awaitToken, Token forToken) {
- seen("ForControlFlow", DirectParserASTType.BEGIN,
- {"awaitToken": awaitToken, "forToken": forToken});
+ DirectParserASTContentForControlFlowBegin data =
+ new DirectParserASTContentForControlFlowBegin(DirectParserASTType.BEGIN,
+ awaitToken: awaitToken, forToken: forToken);
+ seen(data);
}
void endForControlFlow(Token token) {
- seen("ForControlFlow", DirectParserASTType.END, {"token": token});
+ DirectParserASTContentForControlFlowEnd data =
+ new DirectParserASTContentForControlFlowEnd(DirectParserASTType.END,
+ token: token);
+ seen(data);
}
void endForInControlFlow(Token token) {
- seen("ForInControlFlow", DirectParserASTType.END, {"token": token});
+ DirectParserASTContentForInControlFlowEnd data =
+ new DirectParserASTContentForInControlFlowEnd(DirectParserASTType.END,
+ token: token);
+ seen(data);
}
void beginIfControlFlow(Token ifToken) {
- seen("IfControlFlow", DirectParserASTType.BEGIN, {"ifToken": ifToken});
+ DirectParserASTContentIfControlFlowBegin data =
+ new DirectParserASTContentIfControlFlowBegin(DirectParserASTType.BEGIN,
+ ifToken: ifToken);
+ seen(data);
}
void handleThenControlFlow(Token token) {
- seen("ThenControlFlow", DirectParserASTType.HANDLE, {"token": token});
+ DirectParserASTContentThenControlFlowHandle data =
+ new DirectParserASTContentThenControlFlowHandle(
+ DirectParserASTType.HANDLE,
+ token: token);
+ seen(data);
}
void handleElseControlFlow(Token elseToken) {
- seen("ElseControlFlow", DirectParserASTType.HANDLE,
- {"elseToken": elseToken});
+ DirectParserASTContentElseControlFlowHandle data =
+ new DirectParserASTContentElseControlFlowHandle(
+ DirectParserASTType.HANDLE,
+ elseToken: elseToken);
+ seen(data);
}
void endIfControlFlow(Token token) {
- seen("IfControlFlow", DirectParserASTType.END, {"token": token});
+ DirectParserASTContentIfControlFlowEnd data =
+ new DirectParserASTContentIfControlFlowEnd(DirectParserASTType.END,
+ token: token);
+ seen(data);
}
void endIfElseControlFlow(Token token) {
- seen("IfElseControlFlow", DirectParserASTType.END, {"token": token});
+ DirectParserASTContentIfElseControlFlowEnd data =
+ new DirectParserASTContentIfElseControlFlowEnd(DirectParserASTType.END,
+ token: token);
+ seen(data);
}
void handleSpreadExpression(Token spreadToken) {
- seen("SpreadExpression", DirectParserASTType.HANDLE,
- {"spreadToken": spreadToken});
+ DirectParserASTContentSpreadExpressionHandle data =
+ new DirectParserASTContentSpreadExpressionHandle(
+ DirectParserASTType.HANDLE,
+ spreadToken: spreadToken);
+ seen(data);
}
void beginFunctionTypedFormalParameter(Token token) {
- seen("FunctionTypedFormalParameter", DirectParserASTType.BEGIN,
- {"token": token});
+ DirectParserASTContentFunctionTypedFormalParameterBegin data =
+ new DirectParserASTContentFunctionTypedFormalParameterBegin(
+ DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void endFunctionTypedFormalParameter(Token nameToken, Token question) {
- seen("FunctionTypedFormalParameter", DirectParserASTType.END,
- {"nameToken": nameToken, "question": question});
+ DirectParserASTContentFunctionTypedFormalParameterEnd data =
+ new DirectParserASTContentFunctionTypedFormalParameterEnd(
+ DirectParserASTType.END,
+ nameToken: nameToken,
+ question: question);
+ seen(data);
}
void handleIdentifier(Token token, IdentifierContext context) {
- seen("Identifier", DirectParserASTType.HANDLE,
- {"token": token, "context": context});
+ DirectParserASTContentIdentifierHandle data =
+ new DirectParserASTContentIdentifierHandle(DirectParserASTType.HANDLE,
+ token: token, context: context);
+ seen(data);
}
void handleIndexedExpression(
Token question, Token openSquareBracket, Token closeSquareBracket) {
- seen("IndexedExpression", DirectParserASTType.HANDLE, {
- "question": question,
- "openSquareBracket": openSquareBracket,
- "closeSquareBracket": closeSquareBracket
- });
+ DirectParserASTContentIndexedExpressionHandle data =
+ new DirectParserASTContentIndexedExpressionHandle(
+ DirectParserASTType.HANDLE,
+ question: question,
+ openSquareBracket: openSquareBracket,
+ closeSquareBracket: closeSquareBracket);
+ seen(data);
}
void beginIsOperatorType(Token operator) {
- seen("IsOperatorType", DirectParserASTType.BEGIN, {"operator": operator});
+ DirectParserASTContentIsOperatorTypeBegin data =
+ new DirectParserASTContentIsOperatorTypeBegin(DirectParserASTType.BEGIN,
+ operator: operator);
+ seen(data);
}
void endIsOperatorType(Token operator) {
- seen("IsOperatorType", DirectParserASTType.END, {"operator": operator});
+ DirectParserASTContentIsOperatorTypeEnd data =
+ new DirectParserASTContentIsOperatorTypeEnd(DirectParserASTType.END,
+ operator: operator);
+ seen(data);
}
void handleIsOperator(Token isOperator, Token not) {
- seen("IsOperator", DirectParserASTType.HANDLE,
- {"isOperator": isOperator, "not": not});
+ DirectParserASTContentIsOperatorHandle data =
+ new DirectParserASTContentIsOperatorHandle(DirectParserASTType.HANDLE,
+ isOperator: isOperator, not: not);
+ seen(data);
}
void handleLiteralBool(Token token) {
- seen("LiteralBool", DirectParserASTType.HANDLE, {"token": token});
+ DirectParserASTContentLiteralBoolHandle data =
+ new DirectParserASTContentLiteralBoolHandle(DirectParserASTType.HANDLE,
+ token: token);
+ seen(data);
}
void handleBreakStatement(
bool hasTarget, Token breakKeyword, Token endToken) {
- seen("BreakStatement", DirectParserASTType.HANDLE, {
- "hasTarget": hasTarget,
- "breakKeyword": breakKeyword,
- "endToken": endToken
- });
+ DirectParserASTContentBreakStatementHandle data =
+ new DirectParserASTContentBreakStatementHandle(
+ DirectParserASTType.HANDLE,
+ hasTarget: hasTarget,
+ breakKeyword: breakKeyword,
+ endToken: endToken);
+ seen(data);
}
void handleContinueStatement(
bool hasTarget, Token continueKeyword, Token endToken) {
- seen("ContinueStatement", DirectParserASTType.HANDLE, {
- "hasTarget": hasTarget,
- "continueKeyword": continueKeyword,
- "endToken": endToken
- });
+ DirectParserASTContentContinueStatementHandle data =
+ new DirectParserASTContentContinueStatementHandle(
+ DirectParserASTType.HANDLE,
+ hasTarget: hasTarget,
+ continueKeyword: continueKeyword,
+ endToken: endToken);
+ seen(data);
}
void handleEmptyStatement(Token token) {
- seen("EmptyStatement", DirectParserASTType.HANDLE, {"token": token});
+ DirectParserASTContentEmptyStatementHandle data =
+ new DirectParserASTContentEmptyStatementHandle(
+ DirectParserASTType.HANDLE,
+ token: token);
+ seen(data);
}
void beginAssert(Token assertKeyword, Assert kind) {
- seen("Assert", DirectParserASTType.BEGIN,
- {"assertKeyword": assertKeyword, "kind": kind});
+ DirectParserASTContentAssertBegin data =
+ new DirectParserASTContentAssertBegin(DirectParserASTType.BEGIN,
+ assertKeyword: assertKeyword, kind: kind);
+ seen(data);
}
void endAssert(Token assertKeyword, Assert kind, Token leftParenthesis,
Token commaToken, Token semicolonToken) {
- seen("Assert", DirectParserASTType.END, {
- "assertKeyword": assertKeyword,
- "kind": kind,
- "leftParenthesis": leftParenthesis,
- "commaToken": commaToken,
- "semicolonToken": semicolonToken
- });
+ DirectParserASTContentAssertEnd data = new DirectParserASTContentAssertEnd(
+ DirectParserASTType.END,
+ assertKeyword: assertKeyword,
+ kind: kind,
+ leftParenthesis: leftParenthesis,
+ commaToken: commaToken,
+ semicolonToken: semicolonToken);
+ seen(data);
}
void handleLiteralDouble(Token token) {
- seen("LiteralDouble", DirectParserASTType.HANDLE, {"token": token});
+ DirectParserASTContentLiteralDoubleHandle data =
+ new DirectParserASTContentLiteralDoubleHandle(
+ DirectParserASTType.HANDLE,
+ token: token);
+ seen(data);
}
void handleLiteralInt(Token token) {
- seen("LiteralInt", DirectParserASTType.HANDLE, {"token": token});
+ DirectParserASTContentLiteralIntHandle data =
+ new DirectParserASTContentLiteralIntHandle(DirectParserASTType.HANDLE,
+ token: token);
+ seen(data);
}
void handleLiteralList(
int count, Token leftBracket, Token constKeyword, Token rightBracket) {
- seen("LiteralList", DirectParserASTType.HANDLE, {
- "count": count,
- "leftBracket": leftBracket,
- "constKeyword": constKeyword,
- "rightBracket": rightBracket
- });
+ DirectParserASTContentLiteralListHandle data =
+ new DirectParserASTContentLiteralListHandle(DirectParserASTType.HANDLE,
+ count: count,
+ leftBracket: leftBracket,
+ constKeyword: constKeyword,
+ rightBracket: rightBracket);
+ seen(data);
}
void handleLiteralSetOrMap(
@@ -1466,100 +2179,160 @@
Token rightBrace,
bool hasSetEntry,
) {
- seen("LiteralSetOrMap", DirectParserASTType.HANDLE, {
- "count": count,
- "leftBrace": leftBrace,
- "constKeyword": constKeyword,
- "rightBrace": rightBrace,
- "hasSetEntry": hasSetEntry
- });
+ DirectParserASTContentLiteralSetOrMapHandle data =
+ new DirectParserASTContentLiteralSetOrMapHandle(
+ DirectParserASTType.HANDLE,
+ count: count,
+ leftBrace: leftBrace,
+ constKeyword: constKeyword,
+ rightBrace: rightBrace,
+ hasSetEntry: hasSetEntry);
+ seen(data);
}
void handleLiteralNull(Token token) {
- seen("LiteralNull", DirectParserASTType.HANDLE, {"token": token});
+ DirectParserASTContentLiteralNullHandle data =
+ new DirectParserASTContentLiteralNullHandle(DirectParserASTType.HANDLE,
+ token: token);
+ seen(data);
}
void handleNativeClause(Token nativeToken, bool hasName) {
- seen("NativeClause", DirectParserASTType.HANDLE,
- {"nativeToken": nativeToken, "hasName": hasName});
+ DirectParserASTContentNativeClauseHandle data =
+ new DirectParserASTContentNativeClauseHandle(DirectParserASTType.HANDLE,
+ nativeToken: nativeToken, hasName: hasName);
+ seen(data);
}
void handleNamedArgument(Token colon) {
- seen("NamedArgument", DirectParserASTType.HANDLE, {"colon": colon});
+ DirectParserASTContentNamedArgumentHandle data =
+ new DirectParserASTContentNamedArgumentHandle(
+ DirectParserASTType.HANDLE,
+ colon: colon);
+ seen(data);
}
void beginNewExpression(Token token) {
- seen("NewExpression", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentNewExpressionBegin data =
+ new DirectParserASTContentNewExpressionBegin(DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void endNewExpression(Token token) {
- seen("NewExpression", DirectParserASTType.END, {"token": token});
+ DirectParserASTContentNewExpressionEnd data =
+ new DirectParserASTContentNewExpressionEnd(DirectParserASTType.END,
+ token: token);
+ seen(data);
}
void handleNoArguments(Token token) {
- seen("NoArguments", DirectParserASTType.HANDLE, {"token": token});
+ DirectParserASTContentNoArgumentsHandle data =
+ new DirectParserASTContentNoArgumentsHandle(DirectParserASTType.HANDLE,
+ token: token);
+ seen(data);
}
void handleNoConstructorReferenceContinuationAfterTypeArguments(Token token) {
- seen("NoConstructorReferenceContinuationAfterTypeArguments",
- DirectParserASTType.HANDLE, {"token": token});
+ DirectParserASTContentNoConstructorReferenceContinuationAfterTypeArgumentsHandle
+ data =
+ new DirectParserASTContentNoConstructorReferenceContinuationAfterTypeArgumentsHandle(
+ DirectParserASTType.HANDLE,
+ token: token);
+ seen(data);
}
void handleNoType(Token lastConsumed) {
- seen("NoType", DirectParserASTType.HANDLE, {"lastConsumed": lastConsumed});
+ DirectParserASTContentNoTypeHandle data =
+ new DirectParserASTContentNoTypeHandle(DirectParserASTType.HANDLE,
+ lastConsumed: lastConsumed);
+ seen(data);
}
void handleNoTypeVariables(Token token) {
- seen("NoTypeVariables", DirectParserASTType.HANDLE, {"token": token});
+ DirectParserASTContentNoTypeVariablesHandle data =
+ new DirectParserASTContentNoTypeVariablesHandle(
+ DirectParserASTType.HANDLE,
+ token: token);
+ seen(data);
}
void handleOperator(Token token) {
- seen("Operator", DirectParserASTType.HANDLE, {"token": token});
+ DirectParserASTContentOperatorHandle data =
+ new DirectParserASTContentOperatorHandle(DirectParserASTType.HANDLE,
+ token: token);
+ seen(data);
}
void handleSymbolVoid(Token token) {
- seen("SymbolVoid", DirectParserASTType.HANDLE, {"token": token});
+ DirectParserASTContentSymbolVoidHandle data =
+ new DirectParserASTContentSymbolVoidHandle(DirectParserASTType.HANDLE,
+ token: token);
+ seen(data);
}
void handleOperatorName(Token operatorKeyword, Token token) {
- seen("OperatorName", DirectParserASTType.HANDLE,
- {"operatorKeyword": operatorKeyword, "token": token});
+ DirectParserASTContentOperatorNameHandle data =
+ new DirectParserASTContentOperatorNameHandle(DirectParserASTType.HANDLE,
+ operatorKeyword: operatorKeyword, token: token);
+ seen(data);
}
void handleInvalidOperatorName(Token operatorKeyword, Token token) {
- seen("InvalidOperatorName", DirectParserASTType.HANDLE,
- {"operatorKeyword": operatorKeyword, "token": token});
+ DirectParserASTContentInvalidOperatorNameHandle data =
+ new DirectParserASTContentInvalidOperatorNameHandle(
+ DirectParserASTType.HANDLE,
+ operatorKeyword: operatorKeyword,
+ token: token);
+ seen(data);
}
void handleParenthesizedCondition(Token token) {
- seen(
- "ParenthesizedCondition", DirectParserASTType.HANDLE, {"token": token});
+ DirectParserASTContentParenthesizedConditionHandle data =
+ new DirectParserASTContentParenthesizedConditionHandle(
+ DirectParserASTType.HANDLE,
+ token: token);
+ seen(data);
}
void handleParenthesizedExpression(Token token) {
- seen("ParenthesizedExpression", DirectParserASTType.HANDLE,
- {"token": token});
+ DirectParserASTContentParenthesizedExpressionHandle data =
+ new DirectParserASTContentParenthesizedExpressionHandle(
+ DirectParserASTType.HANDLE,
+ token: token);
+ seen(data);
}
void handleQualified(Token period) {
- seen("Qualified", DirectParserASTType.HANDLE, {"period": period});
+ DirectParserASTContentQualifiedHandle data =
+ new DirectParserASTContentQualifiedHandle(DirectParserASTType.HANDLE,
+ period: period);
+ seen(data);
}
void handleStringPart(Token token) {
- seen("StringPart", DirectParserASTType.HANDLE, {"token": token});
+ DirectParserASTContentStringPartHandle data =
+ new DirectParserASTContentStringPartHandle(DirectParserASTType.HANDLE,
+ token: token);
+ seen(data);
}
void handleSuperExpression(Token token, IdentifierContext context) {
- seen("SuperExpression", DirectParserASTType.HANDLE,
- {"token": token, "context": context});
+ DirectParserASTContentSuperExpressionHandle data =
+ new DirectParserASTContentSuperExpressionHandle(
+ DirectParserASTType.HANDLE,
+ token: token,
+ context: context);
+ seen(data);
}
void beginSwitchCase(int labelCount, int expressionCount, Token firstToken) {
- seen("SwitchCase", DirectParserASTType.BEGIN, {
- "labelCount": labelCount,
- "expressionCount": expressionCount,
- "firstToken": firstToken
- });
+ DirectParserASTContentSwitchCaseBegin data =
+ new DirectParserASTContentSwitchCaseBegin(DirectParserASTType.BEGIN,
+ labelCount: labelCount,
+ expressionCount: expressionCount,
+ firstToken: firstToken);
+ seen(data);
}
void endSwitchCase(
@@ -1570,133 +2343,4409 @@
int statementCount,
Token firstToken,
Token endToken) {
- seen("SwitchCase", DirectParserASTType.END, {
- "labelCount": labelCount,
- "expressionCount": expressionCount,
- "defaultKeyword": defaultKeyword,
- "colonAfterDefault": colonAfterDefault,
- "statementCount": statementCount,
- "firstToken": firstToken,
- "endToken": endToken
- });
+ DirectParserASTContentSwitchCaseEnd data =
+ new DirectParserASTContentSwitchCaseEnd(DirectParserASTType.END,
+ labelCount: labelCount,
+ expressionCount: expressionCount,
+ defaultKeyword: defaultKeyword,
+ colonAfterDefault: colonAfterDefault,
+ statementCount: statementCount,
+ firstToken: firstToken,
+ endToken: endToken);
+ seen(data);
}
void handleThisExpression(Token token, IdentifierContext context) {
- seen("ThisExpression", DirectParserASTType.HANDLE,
- {"token": token, "context": context});
+ DirectParserASTContentThisExpressionHandle data =
+ new DirectParserASTContentThisExpressionHandle(
+ DirectParserASTType.HANDLE,
+ token: token,
+ context: context);
+ seen(data);
}
void handleUnaryPostfixAssignmentExpression(Token token) {
- seen("UnaryPostfixAssignmentExpression", DirectParserASTType.HANDLE,
- {"token": token});
+ DirectParserASTContentUnaryPostfixAssignmentExpressionHandle data =
+ new DirectParserASTContentUnaryPostfixAssignmentExpressionHandle(
+ DirectParserASTType.HANDLE,
+ token: token);
+ seen(data);
}
void handleUnaryPrefixExpression(Token token) {
- seen("UnaryPrefixExpression", DirectParserASTType.HANDLE, {"token": token});
+ DirectParserASTContentUnaryPrefixExpressionHandle data =
+ new DirectParserASTContentUnaryPrefixExpressionHandle(
+ DirectParserASTType.HANDLE,
+ token: token);
+ seen(data);
}
void handleUnaryPrefixAssignmentExpression(Token token) {
- seen("UnaryPrefixAssignmentExpression", DirectParserASTType.HANDLE,
- {"token": token});
+ DirectParserASTContentUnaryPrefixAssignmentExpressionHandle data =
+ new DirectParserASTContentUnaryPrefixAssignmentExpressionHandle(
+ DirectParserASTType.HANDLE,
+ token: token);
+ seen(data);
}
void beginFormalParameterDefaultValueExpression() {
- seen(
- "FormalParameterDefaultValueExpression", DirectParserASTType.BEGIN, {});
+ DirectParserASTContentFormalParameterDefaultValueExpressionBegin data =
+ new DirectParserASTContentFormalParameterDefaultValueExpressionBegin(
+ DirectParserASTType.BEGIN);
+ seen(data);
}
void endFormalParameterDefaultValueExpression() {
- seen("FormalParameterDefaultValueExpression", DirectParserASTType.END, {});
+ DirectParserASTContentFormalParameterDefaultValueExpressionEnd data =
+ new DirectParserASTContentFormalParameterDefaultValueExpressionEnd(
+ DirectParserASTType.END);
+ seen(data);
}
void handleValuedFormalParameter(Token equals, Token token) {
- seen("ValuedFormalParameter", DirectParserASTType.HANDLE,
- {"equals": equals, "token": token});
+ DirectParserASTContentValuedFormalParameterHandle data =
+ new DirectParserASTContentValuedFormalParameterHandle(
+ DirectParserASTType.HANDLE,
+ equals: equals,
+ token: token);
+ seen(data);
}
void handleFormalParameterWithoutValue(Token token) {
- seen("FormalParameterWithoutValue", DirectParserASTType.HANDLE,
- {"token": token});
+ DirectParserASTContentFormalParameterWithoutValueHandle data =
+ new DirectParserASTContentFormalParameterWithoutValueHandle(
+ DirectParserASTType.HANDLE,
+ token: token);
+ seen(data);
}
void handleVoidKeyword(Token token) {
- seen("VoidKeyword", DirectParserASTType.HANDLE, {"token": token});
+ DirectParserASTContentVoidKeywordHandle data =
+ new DirectParserASTContentVoidKeywordHandle(DirectParserASTType.HANDLE,
+ token: token);
+ seen(data);
}
void handleVoidKeywordWithTypeArguments(Token token) {
- seen("VoidKeywordWithTypeArguments", DirectParserASTType.HANDLE,
- {"token": token});
+ DirectParserASTContentVoidKeywordWithTypeArgumentsHandle data =
+ new DirectParserASTContentVoidKeywordWithTypeArgumentsHandle(
+ DirectParserASTType.HANDLE,
+ token: token);
+ seen(data);
}
void beginYieldStatement(Token token) {
- seen("YieldStatement", DirectParserASTType.BEGIN, {"token": token});
+ DirectParserASTContentYieldStatementBegin data =
+ new DirectParserASTContentYieldStatementBegin(DirectParserASTType.BEGIN,
+ token: token);
+ seen(data);
}
void endYieldStatement(Token yieldToken, Token starToken, Token endToken) {
- seen("YieldStatement", DirectParserASTType.END, {
- "yieldToken": yieldToken,
- "starToken": starToken,
- "endToken": endToken
- });
+ DirectParserASTContentYieldStatementEnd data =
+ new DirectParserASTContentYieldStatementEnd(DirectParserASTType.END,
+ yieldToken: yieldToken, starToken: starToken, endToken: endToken);
+ seen(data);
}
void endInvalidYieldStatement(Token beginToken, Token starToken,
Token endToken, MessageCode errorCode) {
- seen("InvalidYieldStatement", DirectParserASTType.END, {
- "beginToken": beginToken,
- "starToken": starToken,
- "endToken": endToken,
- "errorCode": errorCode
- });
+ DirectParserASTContentInvalidYieldStatementEnd data =
+ new DirectParserASTContentInvalidYieldStatementEnd(
+ DirectParserASTType.END,
+ beginToken: beginToken,
+ starToken: starToken,
+ endToken: endToken,
+ errorCode: errorCode);
+ seen(data);
}
void handleRecoverableError(
Message message, Token startToken, Token endToken) {
- seen("RecoverableError", DirectParserASTType.HANDLE,
- {"message": message, "startToken": startToken, "endToken": endToken});
+ DirectParserASTContentRecoverableErrorHandle data =
+ new DirectParserASTContentRecoverableErrorHandle(
+ DirectParserASTType.HANDLE,
+ message: message,
+ startToken: startToken,
+ endToken: endToken);
+ seen(data);
}
void handleErrorToken(ErrorToken token) {
- seen("ErrorToken", DirectParserASTType.HANDLE, {"token": token});
+ DirectParserASTContentErrorTokenHandle data =
+ new DirectParserASTContentErrorTokenHandle(DirectParserASTType.HANDLE,
+ token: token);
+ seen(data);
}
void handleUnescapeError(
Message message, Token location, int stringOffset, int length) {
- seen("UnescapeError", DirectParserASTType.HANDLE, {
- "message": message,
- "location": location,
- "stringOffset": stringOffset,
- "length": length
- });
+ DirectParserASTContentUnescapeErrorHandle data =
+ new DirectParserASTContentUnescapeErrorHandle(
+ DirectParserASTType.HANDLE,
+ message: message,
+ location: location,
+ stringOffset: stringOffset,
+ length: length);
+ seen(data);
}
void handleInvalidStatement(Token token, Message message) {
- seen("InvalidStatement", DirectParserASTType.HANDLE,
- {"token": token, "message": message});
+ DirectParserASTContentInvalidStatementHandle data =
+ new DirectParserASTContentInvalidStatementHandle(
+ DirectParserASTType.HANDLE,
+ token: token,
+ message: message);
+ seen(data);
}
void handleScript(Token token) {
- seen("Script", DirectParserASTType.HANDLE, {"token": token});
+ DirectParserASTContentScriptHandle data =
+ new DirectParserASTContentScriptHandle(DirectParserASTType.HANDLE,
+ token: token);
+ seen(data);
}
void handleCommentReferenceText(String referenceSource, int referenceOffset) {
- seen("CommentReferenceText", DirectParserASTType.HANDLE, {
- "referenceSource": referenceSource,
- "referenceOffset": referenceOffset
- });
+ DirectParserASTContentCommentReferenceTextHandle data =
+ new DirectParserASTContentCommentReferenceTextHandle(
+ DirectParserASTType.HANDLE,
+ referenceSource: referenceSource,
+ referenceOffset: referenceOffset);
+ seen(data);
}
void handleCommentReference(
Token newKeyword, Token prefix, Token period, Token token) {
- seen("CommentReference", DirectParserASTType.HANDLE, {
- "newKeyword": newKeyword,
- "prefix": prefix,
- "period": period,
- "token": token
- });
+ DirectParserASTContentCommentReferenceHandle data =
+ new DirectParserASTContentCommentReferenceHandle(
+ DirectParserASTType.HANDLE,
+ newKeyword: newKeyword,
+ prefix: prefix,
+ period: period,
+ token: token);
+ seen(data);
}
void handleNoCommentReference() {
- seen("NoCommentReference", DirectParserASTType.HANDLE, {});
+ DirectParserASTContentNoCommentReferenceHandle data =
+ new DirectParserASTContentNoCommentReferenceHandle(
+ DirectParserASTType.HANDLE);
+ seen(data);
}
}
+
+class DirectParserASTContentArgumentsBegin extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentArgumentsBegin(DirectParserASTType type, {this.token})
+ : super("Arguments", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentArgumentsEnd extends DirectParserASTContent {
+ final int count;
+ final Token beginToken;
+ final Token endToken;
+
+ DirectParserASTContentArgumentsEnd(DirectParserASTType type,
+ {this.count, this.beginToken, this.endToken})
+ : super("Arguments", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "count": count,
+ "beginToken": beginToken,
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentAsyncModifierHandle extends DirectParserASTContent {
+ final Token asyncToken;
+ final Token starToken;
+
+ DirectParserASTContentAsyncModifierHandle(DirectParserASTType type,
+ {this.asyncToken, this.starToken})
+ : super("AsyncModifier", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "asyncToken": asyncToken,
+ "starToken": starToken,
+ };
+}
+
+class DirectParserASTContentAwaitExpressionBegin
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentAwaitExpressionBegin(DirectParserASTType type,
+ {this.token})
+ : super("AwaitExpression", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentAwaitExpressionEnd extends DirectParserASTContent {
+ final Token beginToken;
+ final Token endToken;
+
+ DirectParserASTContentAwaitExpressionEnd(DirectParserASTType type,
+ {this.beginToken, this.endToken})
+ : super("AwaitExpression", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "beginToken": beginToken,
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentInvalidAwaitExpressionEnd
+ extends DirectParserASTContent {
+ final Token beginToken;
+ final Token endToken;
+ final MessageCode errorCode;
+
+ DirectParserASTContentInvalidAwaitExpressionEnd(DirectParserASTType type,
+ {this.beginToken, this.endToken, this.errorCode})
+ : super("InvalidAwaitExpression", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "beginToken": beginToken,
+ "endToken": endToken,
+ "errorCode": errorCode,
+ };
+}
+
+class DirectParserASTContentBlockBegin extends DirectParserASTContent {
+ final Token token;
+ final BlockKind blockKind;
+
+ DirectParserASTContentBlockBegin(DirectParserASTType type,
+ {this.token, this.blockKind})
+ : super("Block", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ "blockKind": blockKind,
+ };
+}
+
+class DirectParserASTContentBlockEnd extends DirectParserASTContent {
+ final int count;
+ final Token beginToken;
+ final Token endToken;
+ final BlockKind blockKind;
+
+ DirectParserASTContentBlockEnd(DirectParserASTType type,
+ {this.count, this.beginToken, this.endToken, this.blockKind})
+ : super("Block", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "count": count,
+ "beginToken": beginToken,
+ "endToken": endToken,
+ "blockKind": blockKind,
+ };
+}
+
+class DirectParserASTContentInvalidTopLevelBlockHandle
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentInvalidTopLevelBlockHandle(DirectParserASTType type,
+ {this.token})
+ : super("InvalidTopLevelBlock", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentCascadeBegin extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentCascadeBegin(DirectParserASTType type, {this.token})
+ : super("Cascade", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentCascadeEnd extends DirectParserASTContent {
+ DirectParserASTContentCascadeEnd(DirectParserASTType type)
+ : super("Cascade", type);
+
+ Map<String, Object> get deprecatedArguments => {};
+}
+
+class DirectParserASTContentCaseExpressionBegin extends DirectParserASTContent {
+ final Token caseKeyword;
+
+ DirectParserASTContentCaseExpressionBegin(DirectParserASTType type,
+ {this.caseKeyword})
+ : super("CaseExpression", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "caseKeyword": caseKeyword,
+ };
+}
+
+class DirectParserASTContentCaseExpressionEnd extends DirectParserASTContent {
+ final Token colon;
+
+ DirectParserASTContentCaseExpressionEnd(DirectParserASTType type,
+ {this.colon})
+ : super("CaseExpression", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "colon": colon,
+ };
+}
+
+class DirectParserASTContentClassOrMixinBodyBegin
+ extends DirectParserASTContent {
+ final DeclarationKind kind;
+ final Token token;
+
+ DirectParserASTContentClassOrMixinBodyBegin(DirectParserASTType type,
+ {this.kind, this.token})
+ : super("ClassOrMixinBody", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "kind": kind,
+ "token": token,
+ };
+}
+
+class DirectParserASTContentClassOrMixinBodyEnd extends DirectParserASTContent {
+ final DeclarationKind kind;
+ final int memberCount;
+ final Token beginToken;
+ final Token endToken;
+
+ DirectParserASTContentClassOrMixinBodyEnd(DirectParserASTType type,
+ {this.kind, this.memberCount, this.beginToken, this.endToken})
+ : super("ClassOrMixinBody", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "kind": kind,
+ "memberCount": memberCount,
+ "beginToken": beginToken,
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentClassOrNamedMixinApplicationPreludeBegin
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentClassOrNamedMixinApplicationPreludeBegin(
+ DirectParserASTType type,
+ {this.token})
+ : super("ClassOrNamedMixinApplicationPrelude", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentClassDeclarationBegin
+ extends DirectParserASTContent {
+ final Token begin;
+ final Token abstractToken;
+ final Token name;
+
+ DirectParserASTContentClassDeclarationBegin(DirectParserASTType type,
+ {this.begin, this.abstractToken, this.name})
+ : super("ClassDeclaration", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "begin": begin,
+ "abstractToken": abstractToken,
+ "name": name,
+ };
+}
+
+class DirectParserASTContentClassExtendsHandle extends DirectParserASTContent {
+ final Token extendsKeyword;
+ final int typeCount;
+
+ DirectParserASTContentClassExtendsHandle(DirectParserASTType type,
+ {this.extendsKeyword, this.typeCount})
+ : super("ClassExtends", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "extendsKeyword": extendsKeyword,
+ "typeCount": typeCount,
+ };
+}
+
+class DirectParserASTContentClassOrMixinImplementsHandle
+ extends DirectParserASTContent {
+ final Token implementsKeyword;
+ final int interfacesCount;
+
+ DirectParserASTContentClassOrMixinImplementsHandle(DirectParserASTType type,
+ {this.implementsKeyword, this.interfacesCount})
+ : super("ClassOrMixinImplements", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "implementsKeyword": implementsKeyword,
+ "interfacesCount": interfacesCount,
+ };
+}
+
+class DirectParserASTContentClassHeaderHandle extends DirectParserASTContent {
+ final Token begin;
+ final Token classKeyword;
+ final Token nativeToken;
+
+ DirectParserASTContentClassHeaderHandle(DirectParserASTType type,
+ {this.begin, this.classKeyword, this.nativeToken})
+ : super("ClassHeader", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "begin": begin,
+ "classKeyword": classKeyword,
+ "nativeToken": nativeToken,
+ };
+}
+
+class DirectParserASTContentRecoverClassHeaderHandle
+ extends DirectParserASTContent {
+ DirectParserASTContentRecoverClassHeaderHandle(DirectParserASTType type)
+ : super("RecoverClassHeader", type);
+
+ Map<String, Object> get deprecatedArguments => {};
+}
+
+class DirectParserASTContentClassDeclarationEnd extends DirectParserASTContent {
+ final Token beginToken;
+ final Token endToken;
+
+ DirectParserASTContentClassDeclarationEnd(DirectParserASTType type,
+ {this.beginToken, this.endToken})
+ : super("ClassDeclaration", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "beginToken": beginToken,
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentMixinDeclarationBegin
+ extends DirectParserASTContent {
+ final Token mixinKeyword;
+ final Token name;
+
+ DirectParserASTContentMixinDeclarationBegin(DirectParserASTType type,
+ {this.mixinKeyword, this.name})
+ : super("MixinDeclaration", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "mixinKeyword": mixinKeyword,
+ "name": name,
+ };
+}
+
+class DirectParserASTContentMixinOnHandle extends DirectParserASTContent {
+ final Token onKeyword;
+ final int typeCount;
+
+ DirectParserASTContentMixinOnHandle(DirectParserASTType type,
+ {this.onKeyword, this.typeCount})
+ : super("MixinOn", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "onKeyword": onKeyword,
+ "typeCount": typeCount,
+ };
+}
+
+class DirectParserASTContentMixinHeaderHandle extends DirectParserASTContent {
+ final Token mixinKeyword;
+
+ DirectParserASTContentMixinHeaderHandle(DirectParserASTType type,
+ {this.mixinKeyword})
+ : super("MixinHeader", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "mixinKeyword": mixinKeyword,
+ };
+}
+
+class DirectParserASTContentRecoverMixinHeaderHandle
+ extends DirectParserASTContent {
+ DirectParserASTContentRecoverMixinHeaderHandle(DirectParserASTType type)
+ : super("RecoverMixinHeader", type);
+
+ Map<String, Object> get deprecatedArguments => {};
+}
+
+class DirectParserASTContentMixinDeclarationEnd extends DirectParserASTContent {
+ final Token mixinKeyword;
+ final Token endToken;
+
+ DirectParserASTContentMixinDeclarationEnd(DirectParserASTType type,
+ {this.mixinKeyword, this.endToken})
+ : super("MixinDeclaration", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "mixinKeyword": mixinKeyword,
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentUncategorizedTopLevelDeclarationBegin
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentUncategorizedTopLevelDeclarationBegin(
+ DirectParserASTType type,
+ {this.token})
+ : super("UncategorizedTopLevelDeclaration", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentExtensionDeclarationPreludeBegin
+ extends DirectParserASTContent {
+ final Token extensionKeyword;
+
+ DirectParserASTContentExtensionDeclarationPreludeBegin(
+ DirectParserASTType type,
+ {this.extensionKeyword})
+ : super("ExtensionDeclarationPrelude", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "extensionKeyword": extensionKeyword,
+ };
+}
+
+class DirectParserASTContentExtensionDeclarationBegin
+ extends DirectParserASTContent {
+ final Token extensionKeyword;
+ final Token name;
+
+ DirectParserASTContentExtensionDeclarationBegin(DirectParserASTType type,
+ {this.extensionKeyword, this.name})
+ : super("ExtensionDeclaration", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "extensionKeyword": extensionKeyword,
+ "name": name,
+ };
+}
+
+class DirectParserASTContentExtensionDeclarationEnd
+ extends DirectParserASTContent {
+ final Token extensionKeyword;
+ final Token onKeyword;
+ final Token endToken;
+
+ DirectParserASTContentExtensionDeclarationEnd(DirectParserASTType type,
+ {this.extensionKeyword, this.onKeyword, this.endToken})
+ : super("ExtensionDeclaration", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "extensionKeyword": extensionKeyword,
+ "onKeyword": onKeyword,
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentCombinatorsBegin extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentCombinatorsBegin(DirectParserASTType type, {this.token})
+ : super("Combinators", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentCombinatorsEnd extends DirectParserASTContent {
+ final int count;
+
+ DirectParserASTContentCombinatorsEnd(DirectParserASTType type, {this.count})
+ : super("Combinators", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "count": count,
+ };
+}
+
+class DirectParserASTContentCompilationUnitBegin
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentCompilationUnitBegin(DirectParserASTType type,
+ {this.token})
+ : super("CompilationUnit", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentDirectivesOnlyHandle
+ extends DirectParserASTContent {
+ DirectParserASTContentDirectivesOnlyHandle(DirectParserASTType type)
+ : super("DirectivesOnly", type);
+
+ Map<String, Object> get deprecatedArguments => {};
+}
+
+class DirectParserASTContentCompilationUnitEnd extends DirectParserASTContent {
+ final int count;
+ final Token token;
+
+ DirectParserASTContentCompilationUnitEnd(DirectParserASTType type,
+ {this.count, this.token})
+ : super("CompilationUnit", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "count": count,
+ "token": token,
+ };
+}
+
+class DirectParserASTContentConstLiteralBegin extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentConstLiteralBegin(DirectParserASTType type,
+ {this.token})
+ : super("ConstLiteral", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentConstLiteralEnd extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentConstLiteralEnd(DirectParserASTType type, {this.token})
+ : super("ConstLiteral", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentConstructorReferenceBegin
+ extends DirectParserASTContent {
+ final Token start;
+
+ DirectParserASTContentConstructorReferenceBegin(DirectParserASTType type,
+ {this.start})
+ : super("ConstructorReference", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "start": start,
+ };
+}
+
+class DirectParserASTContentConstructorReferenceEnd
+ extends DirectParserASTContent {
+ final Token start;
+ final Token periodBeforeName;
+ final Token endToken;
+
+ DirectParserASTContentConstructorReferenceEnd(DirectParserASTType type,
+ {this.start, this.periodBeforeName, this.endToken})
+ : super("ConstructorReference", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "start": start,
+ "periodBeforeName": periodBeforeName,
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentDoWhileStatementBegin
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentDoWhileStatementBegin(DirectParserASTType type,
+ {this.token})
+ : super("DoWhileStatement", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentDoWhileStatementEnd extends DirectParserASTContent {
+ final Token doKeyword;
+ final Token whileKeyword;
+ final Token endToken;
+
+ DirectParserASTContentDoWhileStatementEnd(DirectParserASTType type,
+ {this.doKeyword, this.whileKeyword, this.endToken})
+ : super("DoWhileStatement", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "doKeyword": doKeyword,
+ "whileKeyword": whileKeyword,
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentDoWhileStatementBodyBegin
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentDoWhileStatementBodyBegin(DirectParserASTType type,
+ {this.token})
+ : super("DoWhileStatementBody", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentDoWhileStatementBodyEnd
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentDoWhileStatementBodyEnd(DirectParserASTType type,
+ {this.token})
+ : super("DoWhileStatementBody", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentWhileStatementBodyBegin
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentWhileStatementBodyBegin(DirectParserASTType type,
+ {this.token})
+ : super("WhileStatementBody", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentWhileStatementBodyEnd
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentWhileStatementBodyEnd(DirectParserASTType type,
+ {this.token})
+ : super("WhileStatementBody", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentEnumBegin extends DirectParserASTContent {
+ final Token enumKeyword;
+
+ DirectParserASTContentEnumBegin(DirectParserASTType type, {this.enumKeyword})
+ : super("Enum", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "enumKeyword": enumKeyword,
+ };
+}
+
+class DirectParserASTContentEnumEnd extends DirectParserASTContent {
+ final Token enumKeyword;
+ final Token leftBrace;
+ final int count;
+
+ DirectParserASTContentEnumEnd(DirectParserASTType type,
+ {this.enumKeyword, this.leftBrace, this.count})
+ : super("Enum", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "enumKeyword": enumKeyword,
+ "leftBrace": leftBrace,
+ "count": count,
+ };
+}
+
+class DirectParserASTContentExportBegin extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentExportBegin(DirectParserASTType type, {this.token})
+ : super("Export", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentExportEnd extends DirectParserASTContent {
+ final Token exportKeyword;
+ final Token semicolon;
+
+ DirectParserASTContentExportEnd(DirectParserASTType type,
+ {this.exportKeyword, this.semicolon})
+ : super("Export", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "exportKeyword": exportKeyword,
+ "semicolon": semicolon,
+ };
+}
+
+class DirectParserASTContentExtraneousExpressionHandle
+ extends DirectParserASTContent {
+ final Token token;
+ final Message message;
+
+ DirectParserASTContentExtraneousExpressionHandle(DirectParserASTType type,
+ {this.token, this.message})
+ : super("ExtraneousExpression", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ "message": message,
+ };
+}
+
+class DirectParserASTContentExpressionStatementHandle
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentExpressionStatementHandle(DirectParserASTType type,
+ {this.token})
+ : super("ExpressionStatement", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentFactoryMethodBegin extends DirectParserASTContent {
+ final Token lastConsumed;
+ final Token externalToken;
+ final Token constToken;
+
+ DirectParserASTContentFactoryMethodBegin(DirectParserASTType type,
+ {this.lastConsumed, this.externalToken, this.constToken})
+ : super("FactoryMethod", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "lastConsumed": lastConsumed,
+ "externalToken": externalToken,
+ "constToken": constToken,
+ };
+}
+
+class DirectParserASTContentClassFactoryMethodEnd
+ extends DirectParserASTContent {
+ final Token beginToken;
+ final Token factoryKeyword;
+ final Token endToken;
+
+ DirectParserASTContentClassFactoryMethodEnd(DirectParserASTType type,
+ {this.beginToken, this.factoryKeyword, this.endToken})
+ : super("ClassFactoryMethod", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "beginToken": beginToken,
+ "factoryKeyword": factoryKeyword,
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentMixinFactoryMethodEnd
+ extends DirectParserASTContent {
+ final Token beginToken;
+ final Token factoryKeyword;
+ final Token endToken;
+
+ DirectParserASTContentMixinFactoryMethodEnd(DirectParserASTType type,
+ {this.beginToken, this.factoryKeyword, this.endToken})
+ : super("MixinFactoryMethod", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "beginToken": beginToken,
+ "factoryKeyword": factoryKeyword,
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentExtensionFactoryMethodEnd
+ extends DirectParserASTContent {
+ final Token beginToken;
+ final Token factoryKeyword;
+ final Token endToken;
+
+ DirectParserASTContentExtensionFactoryMethodEnd(DirectParserASTType type,
+ {this.beginToken, this.factoryKeyword, this.endToken})
+ : super("ExtensionFactoryMethod", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "beginToken": beginToken,
+ "factoryKeyword": factoryKeyword,
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentFormalParameterBegin
+ extends DirectParserASTContent {
+ final Token token;
+ final MemberKind kind;
+ final Token requiredToken;
+ final Token covariantToken;
+ final Token varFinalOrConst;
+
+ DirectParserASTContentFormalParameterBegin(DirectParserASTType type,
+ {this.token,
+ this.kind,
+ this.requiredToken,
+ this.covariantToken,
+ this.varFinalOrConst})
+ : super("FormalParameter", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ "kind": kind,
+ "requiredToken": requiredToken,
+ "covariantToken": covariantToken,
+ "varFinalOrConst": varFinalOrConst,
+ };
+}
+
+class DirectParserASTContentFormalParameterEnd extends DirectParserASTContent {
+ final Token thisKeyword;
+ final Token periodAfterThis;
+ final Token nameToken;
+ final Token initializerStart;
+ final Token initializerEnd;
+ final FormalParameterKind kind;
+ final MemberKind memberKind;
+
+ DirectParserASTContentFormalParameterEnd(DirectParserASTType type,
+ {this.thisKeyword,
+ this.periodAfterThis,
+ this.nameToken,
+ this.initializerStart,
+ this.initializerEnd,
+ this.kind,
+ this.memberKind})
+ : super("FormalParameter", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "thisKeyword": thisKeyword,
+ "periodAfterThis": periodAfterThis,
+ "nameToken": nameToken,
+ "initializerStart": initializerStart,
+ "initializerEnd": initializerEnd,
+ "kind": kind,
+ "memberKind": memberKind,
+ };
+}
+
+class DirectParserASTContentNoFormalParametersHandle
+ extends DirectParserASTContent {
+ final Token token;
+ final MemberKind kind;
+
+ DirectParserASTContentNoFormalParametersHandle(DirectParserASTType type,
+ {this.token, this.kind})
+ : super("NoFormalParameters", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ "kind": kind,
+ };
+}
+
+class DirectParserASTContentFormalParametersBegin
+ extends DirectParserASTContent {
+ final Token token;
+ final MemberKind kind;
+
+ DirectParserASTContentFormalParametersBegin(DirectParserASTType type,
+ {this.token, this.kind})
+ : super("FormalParameters", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ "kind": kind,
+ };
+}
+
+class DirectParserASTContentFormalParametersEnd extends DirectParserASTContent {
+ final int count;
+ final Token beginToken;
+ final Token endToken;
+ final MemberKind kind;
+
+ DirectParserASTContentFormalParametersEnd(DirectParserASTType type,
+ {this.count, this.beginToken, this.endToken, this.kind})
+ : super("FormalParameters", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "count": count,
+ "beginToken": beginToken,
+ "endToken": endToken,
+ "kind": kind,
+ };
+}
+
+class DirectParserASTContentClassFieldsEnd extends DirectParserASTContent {
+ final Token abstractToken;
+ final Token externalToken;
+ final Token staticToken;
+ final Token covariantToken;
+ final Token lateToken;
+ final Token varFinalOrConst;
+ final int count;
+ final Token beginToken;
+ final Token endToken;
+
+ DirectParserASTContentClassFieldsEnd(DirectParserASTType type,
+ {this.abstractToken,
+ this.externalToken,
+ this.staticToken,
+ this.covariantToken,
+ this.lateToken,
+ this.varFinalOrConst,
+ this.count,
+ this.beginToken,
+ this.endToken})
+ : super("ClassFields", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "abstractToken": abstractToken,
+ "externalToken": externalToken,
+ "staticToken": staticToken,
+ "covariantToken": covariantToken,
+ "lateToken": lateToken,
+ "varFinalOrConst": varFinalOrConst,
+ "count": count,
+ "beginToken": beginToken,
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentMixinFieldsEnd extends DirectParserASTContent {
+ final Token abstractToken;
+ final Token externalToken;
+ final Token staticToken;
+ final Token covariantToken;
+ final Token lateToken;
+ final Token varFinalOrConst;
+ final int count;
+ final Token beginToken;
+ final Token endToken;
+
+ DirectParserASTContentMixinFieldsEnd(DirectParserASTType type,
+ {this.abstractToken,
+ this.externalToken,
+ this.staticToken,
+ this.covariantToken,
+ this.lateToken,
+ this.varFinalOrConst,
+ this.count,
+ this.beginToken,
+ this.endToken})
+ : super("MixinFields", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "abstractToken": abstractToken,
+ "externalToken": externalToken,
+ "staticToken": staticToken,
+ "covariantToken": covariantToken,
+ "lateToken": lateToken,
+ "varFinalOrConst": varFinalOrConst,
+ "count": count,
+ "beginToken": beginToken,
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentExtensionFieldsEnd extends DirectParserASTContent {
+ final Token abstractToken;
+ final Token externalToken;
+ final Token staticToken;
+ final Token covariantToken;
+ final Token lateToken;
+ final Token varFinalOrConst;
+ final int count;
+ final Token beginToken;
+ final Token endToken;
+
+ DirectParserASTContentExtensionFieldsEnd(DirectParserASTType type,
+ {this.abstractToken,
+ this.externalToken,
+ this.staticToken,
+ this.covariantToken,
+ this.lateToken,
+ this.varFinalOrConst,
+ this.count,
+ this.beginToken,
+ this.endToken})
+ : super("ExtensionFields", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "abstractToken": abstractToken,
+ "externalToken": externalToken,
+ "staticToken": staticToken,
+ "covariantToken": covariantToken,
+ "lateToken": lateToken,
+ "varFinalOrConst": varFinalOrConst,
+ "count": count,
+ "beginToken": beginToken,
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentForInitializerEmptyStatementHandle
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentForInitializerEmptyStatementHandle(
+ DirectParserASTType type,
+ {this.token})
+ : super("ForInitializerEmptyStatement", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentForInitializerExpressionStatementHandle
+ extends DirectParserASTContent {
+ final Token token;
+ final bool forIn;
+
+ DirectParserASTContentForInitializerExpressionStatementHandle(
+ DirectParserASTType type,
+ {this.token,
+ this.forIn})
+ : super("ForInitializerExpressionStatement", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ "forIn": forIn,
+ };
+}
+
+class DirectParserASTContentForInitializerLocalVariableDeclarationHandle
+ extends DirectParserASTContent {
+ final Token token;
+ final bool forIn;
+
+ DirectParserASTContentForInitializerLocalVariableDeclarationHandle(
+ DirectParserASTType type,
+ {this.token,
+ this.forIn})
+ : super("ForInitializerLocalVariableDeclaration", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ "forIn": forIn,
+ };
+}
+
+class DirectParserASTContentForStatementBegin extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentForStatementBegin(DirectParserASTType type,
+ {this.token})
+ : super("ForStatement", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentForLoopPartsHandle extends DirectParserASTContent {
+ final Token forKeyword;
+ final Token leftParen;
+ final Token leftSeparator;
+ final int updateExpressionCount;
+
+ DirectParserASTContentForLoopPartsHandle(DirectParserASTType type,
+ {this.forKeyword,
+ this.leftParen,
+ this.leftSeparator,
+ this.updateExpressionCount})
+ : super("ForLoopParts", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "forKeyword": forKeyword,
+ "leftParen": leftParen,
+ "leftSeparator": leftSeparator,
+ "updateExpressionCount": updateExpressionCount,
+ };
+}
+
+class DirectParserASTContentForStatementEnd extends DirectParserASTContent {
+ final Token endToken;
+
+ DirectParserASTContentForStatementEnd(DirectParserASTType type,
+ {this.endToken})
+ : super("ForStatement", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentForStatementBodyBegin
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentForStatementBodyBegin(DirectParserASTType type,
+ {this.token})
+ : super("ForStatementBody", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentForStatementBodyEnd extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentForStatementBodyEnd(DirectParserASTType type,
+ {this.token})
+ : super("ForStatementBody", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentForInLoopPartsHandle
+ extends DirectParserASTContent {
+ final Token awaitToken;
+ final Token forToken;
+ final Token leftParenthesis;
+ final Token inKeyword;
+
+ DirectParserASTContentForInLoopPartsHandle(DirectParserASTType type,
+ {this.awaitToken, this.forToken, this.leftParenthesis, this.inKeyword})
+ : super("ForInLoopParts", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "awaitToken": awaitToken,
+ "forToken": forToken,
+ "leftParenthesis": leftParenthesis,
+ "inKeyword": inKeyword,
+ };
+}
+
+class DirectParserASTContentForInEnd extends DirectParserASTContent {
+ final Token endToken;
+
+ DirectParserASTContentForInEnd(DirectParserASTType type, {this.endToken})
+ : super("ForIn", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentForInExpressionBegin
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentForInExpressionBegin(DirectParserASTType type,
+ {this.token})
+ : super("ForInExpression", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentForInExpressionEnd extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentForInExpressionEnd(DirectParserASTType type,
+ {this.token})
+ : super("ForInExpression", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentForInBodyBegin extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentForInBodyBegin(DirectParserASTType type, {this.token})
+ : super("ForInBody", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentForInBodyEnd extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentForInBodyEnd(DirectParserASTType type, {this.token})
+ : super("ForInBody", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentNamedFunctionExpressionBegin
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentNamedFunctionExpressionBegin(DirectParserASTType type,
+ {this.token})
+ : super("NamedFunctionExpression", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentNamedFunctionExpressionEnd
+ extends DirectParserASTContent {
+ final Token endToken;
+
+ DirectParserASTContentNamedFunctionExpressionEnd(DirectParserASTType type,
+ {this.endToken})
+ : super("NamedFunctionExpression", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentLocalFunctionDeclarationBegin
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentLocalFunctionDeclarationBegin(DirectParserASTType type,
+ {this.token})
+ : super("LocalFunctionDeclaration", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentLocalFunctionDeclarationEnd
+ extends DirectParserASTContent {
+ final Token endToken;
+
+ DirectParserASTContentLocalFunctionDeclarationEnd(DirectParserASTType type,
+ {this.endToken})
+ : super("LocalFunctionDeclaration", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentBlockFunctionBodyBegin
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentBlockFunctionBodyBegin(DirectParserASTType type,
+ {this.token})
+ : super("BlockFunctionBody", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentBlockFunctionBodyEnd
+ extends DirectParserASTContent {
+ final int count;
+ final Token beginToken;
+ final Token endToken;
+
+ DirectParserASTContentBlockFunctionBodyEnd(DirectParserASTType type,
+ {this.count, this.beginToken, this.endToken})
+ : super("BlockFunctionBody", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "count": count,
+ "beginToken": beginToken,
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentNoFunctionBodyHandle
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentNoFunctionBodyHandle(DirectParserASTType type,
+ {this.token})
+ : super("NoFunctionBody", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentFunctionBodySkippedHandle
+ extends DirectParserASTContent {
+ final Token token;
+ final bool isExpressionBody;
+
+ DirectParserASTContentFunctionBodySkippedHandle(DirectParserASTType type,
+ {this.token, this.isExpressionBody})
+ : super("FunctionBodySkipped", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ "isExpressionBody": isExpressionBody,
+ };
+}
+
+class DirectParserASTContentFunctionNameBegin extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentFunctionNameBegin(DirectParserASTType type,
+ {this.token})
+ : super("FunctionName", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentFunctionNameEnd extends DirectParserASTContent {
+ final Token beginToken;
+ final Token token;
+
+ DirectParserASTContentFunctionNameEnd(DirectParserASTType type,
+ {this.beginToken, this.token})
+ : super("FunctionName", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "beginToken": beginToken,
+ "token": token,
+ };
+}
+
+class DirectParserASTContentFunctionTypeAliasBegin
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentFunctionTypeAliasBegin(DirectParserASTType type,
+ {this.token})
+ : super("FunctionTypeAlias", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentFunctionTypeAliasEnd
+ extends DirectParserASTContent {
+ final Token typedefKeyword;
+ final Token equals;
+ final Token endToken;
+
+ DirectParserASTContentFunctionTypeAliasEnd(DirectParserASTType type,
+ {this.typedefKeyword, this.equals, this.endToken})
+ : super("FunctionTypeAlias", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "typedefKeyword": typedefKeyword,
+ "equals": equals,
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentClassWithClauseHandle
+ extends DirectParserASTContent {
+ final Token withKeyword;
+
+ DirectParserASTContentClassWithClauseHandle(DirectParserASTType type,
+ {this.withKeyword})
+ : super("ClassWithClause", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "withKeyword": withKeyword,
+ };
+}
+
+class DirectParserASTContentClassNoWithClauseHandle
+ extends DirectParserASTContent {
+ DirectParserASTContentClassNoWithClauseHandle(DirectParserASTType type)
+ : super("ClassNoWithClause", type);
+
+ Map<String, Object> get deprecatedArguments => {};
+}
+
+class DirectParserASTContentNamedMixinApplicationBegin
+ extends DirectParserASTContent {
+ final Token begin;
+ final Token abstractToken;
+ final Token name;
+
+ DirectParserASTContentNamedMixinApplicationBegin(DirectParserASTType type,
+ {this.begin, this.abstractToken, this.name})
+ : super("NamedMixinApplication", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "begin": begin,
+ "abstractToken": abstractToken,
+ "name": name,
+ };
+}
+
+class DirectParserASTContentNamedMixinApplicationWithClauseHandle
+ extends DirectParserASTContent {
+ final Token withKeyword;
+
+ DirectParserASTContentNamedMixinApplicationWithClauseHandle(
+ DirectParserASTType type,
+ {this.withKeyword})
+ : super("NamedMixinApplicationWithClause", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "withKeyword": withKeyword,
+ };
+}
+
+class DirectParserASTContentNamedMixinApplicationEnd
+ extends DirectParserASTContent {
+ final Token begin;
+ final Token classKeyword;
+ final Token equals;
+ final Token implementsKeyword;
+ final Token endToken;
+
+ DirectParserASTContentNamedMixinApplicationEnd(DirectParserASTType type,
+ {this.begin,
+ this.classKeyword,
+ this.equals,
+ this.implementsKeyword,
+ this.endToken})
+ : super("NamedMixinApplication", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "begin": begin,
+ "classKeyword": classKeyword,
+ "equals": equals,
+ "implementsKeyword": implementsKeyword,
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentHideBegin extends DirectParserASTContent {
+ final Token hideKeyword;
+
+ DirectParserASTContentHideBegin(DirectParserASTType type, {this.hideKeyword})
+ : super("Hide", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "hideKeyword": hideKeyword,
+ };
+}
+
+class DirectParserASTContentHideEnd extends DirectParserASTContent {
+ final Token hideKeyword;
+
+ DirectParserASTContentHideEnd(DirectParserASTType type, {this.hideKeyword})
+ : super("Hide", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "hideKeyword": hideKeyword,
+ };
+}
+
+class DirectParserASTContentIdentifierListHandle
+ extends DirectParserASTContent {
+ final int count;
+
+ DirectParserASTContentIdentifierListHandle(DirectParserASTType type,
+ {this.count})
+ : super("IdentifierList", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "count": count,
+ };
+}
+
+class DirectParserASTContentTypeListBegin extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentTypeListBegin(DirectParserASTType type, {this.token})
+ : super("TypeList", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentTypeListEnd extends DirectParserASTContent {
+ final int count;
+
+ DirectParserASTContentTypeListEnd(DirectParserASTType type, {this.count})
+ : super("TypeList", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "count": count,
+ };
+}
+
+class DirectParserASTContentIfStatementBegin extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentIfStatementBegin(DirectParserASTType type, {this.token})
+ : super("IfStatement", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentIfStatementEnd extends DirectParserASTContent {
+ final Token ifToken;
+ final Token elseToken;
+
+ DirectParserASTContentIfStatementEnd(DirectParserASTType type,
+ {this.ifToken, this.elseToken})
+ : super("IfStatement", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "ifToken": ifToken,
+ "elseToken": elseToken,
+ };
+}
+
+class DirectParserASTContentThenStatementBegin extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentThenStatementBegin(DirectParserASTType type,
+ {this.token})
+ : super("ThenStatement", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentThenStatementEnd extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentThenStatementEnd(DirectParserASTType type, {this.token})
+ : super("ThenStatement", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentElseStatementBegin extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentElseStatementBegin(DirectParserASTType type,
+ {this.token})
+ : super("ElseStatement", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentElseStatementEnd extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentElseStatementEnd(DirectParserASTType type, {this.token})
+ : super("ElseStatement", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentImportBegin extends DirectParserASTContent {
+ final Token importKeyword;
+
+ DirectParserASTContentImportBegin(DirectParserASTType type,
+ {this.importKeyword})
+ : super("Import", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "importKeyword": importKeyword,
+ };
+}
+
+class DirectParserASTContentImportPrefixHandle extends DirectParserASTContent {
+ final Token deferredKeyword;
+ final Token asKeyword;
+
+ DirectParserASTContentImportPrefixHandle(DirectParserASTType type,
+ {this.deferredKeyword, this.asKeyword})
+ : super("ImportPrefix", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "deferredKeyword": deferredKeyword,
+ "asKeyword": asKeyword,
+ };
+}
+
+class DirectParserASTContentImportEnd extends DirectParserASTContent {
+ final Token importKeyword;
+ final Token semicolon;
+
+ DirectParserASTContentImportEnd(DirectParserASTType type,
+ {this.importKeyword, this.semicolon})
+ : super("Import", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "importKeyword": importKeyword,
+ "semicolon": semicolon,
+ };
+}
+
+class DirectParserASTContentRecoverImportHandle extends DirectParserASTContent {
+ final Token semicolon;
+
+ DirectParserASTContentRecoverImportHandle(DirectParserASTType type,
+ {this.semicolon})
+ : super("RecoverImport", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "semicolon": semicolon,
+ };
+}
+
+class DirectParserASTContentConditionalUrisBegin
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentConditionalUrisBegin(DirectParserASTType type,
+ {this.token})
+ : super("ConditionalUris", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentConditionalUrisEnd extends DirectParserASTContent {
+ final int count;
+
+ DirectParserASTContentConditionalUrisEnd(DirectParserASTType type,
+ {this.count})
+ : super("ConditionalUris", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "count": count,
+ };
+}
+
+class DirectParserASTContentConditionalUriBegin extends DirectParserASTContent {
+ final Token ifKeyword;
+
+ DirectParserASTContentConditionalUriBegin(DirectParserASTType type,
+ {this.ifKeyword})
+ : super("ConditionalUri", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "ifKeyword": ifKeyword,
+ };
+}
+
+class DirectParserASTContentConditionalUriEnd extends DirectParserASTContent {
+ final Token ifKeyword;
+ final Token leftParen;
+ final Token equalSign;
+
+ DirectParserASTContentConditionalUriEnd(DirectParserASTType type,
+ {this.ifKeyword, this.leftParen, this.equalSign})
+ : super("ConditionalUri", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "ifKeyword": ifKeyword,
+ "leftParen": leftParen,
+ "equalSign": equalSign,
+ };
+}
+
+class DirectParserASTContentDottedNameHandle extends DirectParserASTContent {
+ final int count;
+ final Token firstIdentifier;
+
+ DirectParserASTContentDottedNameHandle(DirectParserASTType type,
+ {this.count, this.firstIdentifier})
+ : super("DottedName", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "count": count,
+ "firstIdentifier": firstIdentifier,
+ };
+}
+
+class DirectParserASTContentImplicitCreationExpressionBegin
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentImplicitCreationExpressionBegin(
+ DirectParserASTType type,
+ {this.token})
+ : super("ImplicitCreationExpression", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentImplicitCreationExpressionEnd
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentImplicitCreationExpressionEnd(DirectParserASTType type,
+ {this.token})
+ : super("ImplicitCreationExpression", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentInitializedIdentifierBegin
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentInitializedIdentifierBegin(DirectParserASTType type,
+ {this.token})
+ : super("InitializedIdentifier", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentInitializedIdentifierEnd
+ extends DirectParserASTContent {
+ final Token nameToken;
+
+ DirectParserASTContentInitializedIdentifierEnd(DirectParserASTType type,
+ {this.nameToken})
+ : super("InitializedIdentifier", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "nameToken": nameToken,
+ };
+}
+
+class DirectParserASTContentFieldInitializerBegin
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentFieldInitializerBegin(DirectParserASTType type,
+ {this.token})
+ : super("FieldInitializer", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentFieldInitializerEnd extends DirectParserASTContent {
+ final Token assignment;
+ final Token token;
+
+ DirectParserASTContentFieldInitializerEnd(DirectParserASTType type,
+ {this.assignment, this.token})
+ : super("FieldInitializer", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "assignment": assignment,
+ "token": token,
+ };
+}
+
+class DirectParserASTContentNoFieldInitializerHandle
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentNoFieldInitializerHandle(DirectParserASTType type,
+ {this.token})
+ : super("NoFieldInitializer", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentVariableInitializerBegin
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentVariableInitializerBegin(DirectParserASTType type,
+ {this.token})
+ : super("VariableInitializer", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentVariableInitializerEnd
+ extends DirectParserASTContent {
+ final Token assignmentOperator;
+
+ DirectParserASTContentVariableInitializerEnd(DirectParserASTType type,
+ {this.assignmentOperator})
+ : super("VariableInitializer", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "assignmentOperator": assignmentOperator,
+ };
+}
+
+class DirectParserASTContentNoVariableInitializerHandle
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentNoVariableInitializerHandle(DirectParserASTType type,
+ {this.token})
+ : super("NoVariableInitializer", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentInitializerBegin extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentInitializerBegin(DirectParserASTType type, {this.token})
+ : super("Initializer", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentInitializerEnd extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentInitializerEnd(DirectParserASTType type, {this.token})
+ : super("Initializer", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentInitializersBegin extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentInitializersBegin(DirectParserASTType type,
+ {this.token})
+ : super("Initializers", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentInitializersEnd extends DirectParserASTContent {
+ final int count;
+ final Token beginToken;
+ final Token endToken;
+
+ DirectParserASTContentInitializersEnd(DirectParserASTType type,
+ {this.count, this.beginToken, this.endToken})
+ : super("Initializers", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "count": count,
+ "beginToken": beginToken,
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentNoInitializersHandle
+ extends DirectParserASTContent {
+ DirectParserASTContentNoInitializersHandle(DirectParserASTType type)
+ : super("NoInitializers", type);
+
+ Map<String, Object> get deprecatedArguments => {};
+}
+
+class DirectParserASTContentInvalidExpressionHandle
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentInvalidExpressionHandle(DirectParserASTType type,
+ {this.token})
+ : super("InvalidExpression", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentInvalidFunctionBodyHandle
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentInvalidFunctionBodyHandle(DirectParserASTType type,
+ {this.token})
+ : super("InvalidFunctionBody", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentInvalidTypeReferenceHandle
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentInvalidTypeReferenceHandle(DirectParserASTType type,
+ {this.token})
+ : super("InvalidTypeReference", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentLabelHandle extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentLabelHandle(DirectParserASTType type, {this.token})
+ : super("Label", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentLabeledStatementBegin
+ extends DirectParserASTContent {
+ final Token token;
+ final int labelCount;
+
+ DirectParserASTContentLabeledStatementBegin(DirectParserASTType type,
+ {this.token, this.labelCount})
+ : super("LabeledStatement", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ "labelCount": labelCount,
+ };
+}
+
+class DirectParserASTContentLabeledStatementEnd extends DirectParserASTContent {
+ final int labelCount;
+
+ DirectParserASTContentLabeledStatementEnd(DirectParserASTType type,
+ {this.labelCount})
+ : super("LabeledStatement", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "labelCount": labelCount,
+ };
+}
+
+class DirectParserASTContentLibraryNameBegin extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentLibraryNameBegin(DirectParserASTType type, {this.token})
+ : super("LibraryName", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentLibraryNameEnd extends DirectParserASTContent {
+ final Token libraryKeyword;
+ final Token semicolon;
+
+ DirectParserASTContentLibraryNameEnd(DirectParserASTType type,
+ {this.libraryKeyword, this.semicolon})
+ : super("LibraryName", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "libraryKeyword": libraryKeyword,
+ "semicolon": semicolon,
+ };
+}
+
+class DirectParserASTContentLiteralMapEntryHandle
+ extends DirectParserASTContent {
+ final Token colon;
+ final Token endToken;
+
+ DirectParserASTContentLiteralMapEntryHandle(DirectParserASTType type,
+ {this.colon, this.endToken})
+ : super("LiteralMapEntry", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "colon": colon,
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentLiteralStringBegin extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentLiteralStringBegin(DirectParserASTType type,
+ {this.token})
+ : super("LiteralString", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentInterpolationExpressionHandle
+ extends DirectParserASTContent {
+ final Token leftBracket;
+ final Token rightBracket;
+
+ DirectParserASTContentInterpolationExpressionHandle(DirectParserASTType type,
+ {this.leftBracket, this.rightBracket})
+ : super("InterpolationExpression", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "leftBracket": leftBracket,
+ "rightBracket": rightBracket,
+ };
+}
+
+class DirectParserASTContentLiteralStringEnd extends DirectParserASTContent {
+ final int interpolationCount;
+ final Token endToken;
+
+ DirectParserASTContentLiteralStringEnd(DirectParserASTType type,
+ {this.interpolationCount, this.endToken})
+ : super("LiteralString", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "interpolationCount": interpolationCount,
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentStringJuxtapositionHandle
+ extends DirectParserASTContent {
+ final Token startToken;
+ final int literalCount;
+
+ DirectParserASTContentStringJuxtapositionHandle(DirectParserASTType type,
+ {this.startToken, this.literalCount})
+ : super("StringJuxtaposition", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "startToken": startToken,
+ "literalCount": literalCount,
+ };
+}
+
+class DirectParserASTContentMemberBegin extends DirectParserASTContent {
+ DirectParserASTContentMemberBegin(DirectParserASTType type)
+ : super("Member", type);
+
+ Map<String, Object> get deprecatedArguments => {};
+}
+
+class DirectParserASTContentInvalidMemberHandle extends DirectParserASTContent {
+ final Token endToken;
+
+ DirectParserASTContentInvalidMemberHandle(DirectParserASTType type,
+ {this.endToken})
+ : super("InvalidMember", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentMemberEnd extends DirectParserASTContent {
+ DirectParserASTContentMemberEnd(DirectParserASTType type)
+ : super("Member", type);
+
+ Map<String, Object> get deprecatedArguments => {};
+}
+
+class DirectParserASTContentMethodBegin extends DirectParserASTContent {
+ final Token externalToken;
+ final Token staticToken;
+ final Token covariantToken;
+ final Token varFinalOrConst;
+ final Token getOrSet;
+ final Token name;
+
+ DirectParserASTContentMethodBegin(DirectParserASTType type,
+ {this.externalToken,
+ this.staticToken,
+ this.covariantToken,
+ this.varFinalOrConst,
+ this.getOrSet,
+ this.name})
+ : super("Method", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "externalToken": externalToken,
+ "staticToken": staticToken,
+ "covariantToken": covariantToken,
+ "varFinalOrConst": varFinalOrConst,
+ "getOrSet": getOrSet,
+ "name": name,
+ };
+}
+
+class DirectParserASTContentClassMethodEnd extends DirectParserASTContent {
+ final Token getOrSet;
+ final Token beginToken;
+ final Token beginParam;
+ final Token beginInitializers;
+ final Token endToken;
+
+ DirectParserASTContentClassMethodEnd(DirectParserASTType type,
+ {this.getOrSet,
+ this.beginToken,
+ this.beginParam,
+ this.beginInitializers,
+ this.endToken})
+ : super("ClassMethod", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "getOrSet": getOrSet,
+ "beginToken": beginToken,
+ "beginParam": beginParam,
+ "beginInitializers": beginInitializers,
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentMixinMethodEnd extends DirectParserASTContent {
+ final Token getOrSet;
+ final Token beginToken;
+ final Token beginParam;
+ final Token beginInitializers;
+ final Token endToken;
+
+ DirectParserASTContentMixinMethodEnd(DirectParserASTType type,
+ {this.getOrSet,
+ this.beginToken,
+ this.beginParam,
+ this.beginInitializers,
+ this.endToken})
+ : super("MixinMethod", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "getOrSet": getOrSet,
+ "beginToken": beginToken,
+ "beginParam": beginParam,
+ "beginInitializers": beginInitializers,
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentExtensionMethodEnd extends DirectParserASTContent {
+ final Token getOrSet;
+ final Token beginToken;
+ final Token beginParam;
+ final Token beginInitializers;
+ final Token endToken;
+
+ DirectParserASTContentExtensionMethodEnd(DirectParserASTType type,
+ {this.getOrSet,
+ this.beginToken,
+ this.beginParam,
+ this.beginInitializers,
+ this.endToken})
+ : super("ExtensionMethod", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "getOrSet": getOrSet,
+ "beginToken": beginToken,
+ "beginParam": beginParam,
+ "beginInitializers": beginInitializers,
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentClassConstructorEnd extends DirectParserASTContent {
+ final Token getOrSet;
+ final Token beginToken;
+ final Token beginParam;
+ final Token beginInitializers;
+ final Token endToken;
+
+ DirectParserASTContentClassConstructorEnd(DirectParserASTType type,
+ {this.getOrSet,
+ this.beginToken,
+ this.beginParam,
+ this.beginInitializers,
+ this.endToken})
+ : super("ClassConstructor", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "getOrSet": getOrSet,
+ "beginToken": beginToken,
+ "beginParam": beginParam,
+ "beginInitializers": beginInitializers,
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentMixinConstructorEnd extends DirectParserASTContent {
+ final Token getOrSet;
+ final Token beginToken;
+ final Token beginParam;
+ final Token beginInitializers;
+ final Token endToken;
+
+ DirectParserASTContentMixinConstructorEnd(DirectParserASTType type,
+ {this.getOrSet,
+ this.beginToken,
+ this.beginParam,
+ this.beginInitializers,
+ this.endToken})
+ : super("MixinConstructor", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "getOrSet": getOrSet,
+ "beginToken": beginToken,
+ "beginParam": beginParam,
+ "beginInitializers": beginInitializers,
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentExtensionConstructorEnd
+ extends DirectParserASTContent {
+ final Token getOrSet;
+ final Token beginToken;
+ final Token beginParam;
+ final Token beginInitializers;
+ final Token endToken;
+
+ DirectParserASTContentExtensionConstructorEnd(DirectParserASTType type,
+ {this.getOrSet,
+ this.beginToken,
+ this.beginParam,
+ this.beginInitializers,
+ this.endToken})
+ : super("ExtensionConstructor", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "getOrSet": getOrSet,
+ "beginToken": beginToken,
+ "beginParam": beginParam,
+ "beginInitializers": beginInitializers,
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentMetadataStarBegin extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentMetadataStarBegin(DirectParserASTType type,
+ {this.token})
+ : super("MetadataStar", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentMetadataStarEnd extends DirectParserASTContent {
+ final int count;
+
+ DirectParserASTContentMetadataStarEnd(DirectParserASTType type, {this.count})
+ : super("MetadataStar", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "count": count,
+ };
+}
+
+class DirectParserASTContentMetadataBegin extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentMetadataBegin(DirectParserASTType type, {this.token})
+ : super("Metadata", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentMetadataEnd extends DirectParserASTContent {
+ final Token beginToken;
+ final Token periodBeforeName;
+ final Token endToken;
+
+ DirectParserASTContentMetadataEnd(DirectParserASTType type,
+ {this.beginToken, this.periodBeforeName, this.endToken})
+ : super("Metadata", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "beginToken": beginToken,
+ "periodBeforeName": periodBeforeName,
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentOptionalFormalParametersBegin
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentOptionalFormalParametersBegin(DirectParserASTType type,
+ {this.token})
+ : super("OptionalFormalParameters", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentOptionalFormalParametersEnd
+ extends DirectParserASTContent {
+ final int count;
+ final Token beginToken;
+ final Token endToken;
+
+ DirectParserASTContentOptionalFormalParametersEnd(DirectParserASTType type,
+ {this.count, this.beginToken, this.endToken})
+ : super("OptionalFormalParameters", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "count": count,
+ "beginToken": beginToken,
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentPartBegin extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentPartBegin(DirectParserASTType type, {this.token})
+ : super("Part", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentPartEnd extends DirectParserASTContent {
+ final Token partKeyword;
+ final Token semicolon;
+
+ DirectParserASTContentPartEnd(DirectParserASTType type,
+ {this.partKeyword, this.semicolon})
+ : super("Part", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "partKeyword": partKeyword,
+ "semicolon": semicolon,
+ };
+}
+
+class DirectParserASTContentPartOfBegin extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentPartOfBegin(DirectParserASTType type, {this.token})
+ : super("PartOf", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentPartOfEnd extends DirectParserASTContent {
+ final Token partKeyword;
+ final Token ofKeyword;
+ final Token semicolon;
+ final bool hasName;
+
+ DirectParserASTContentPartOfEnd(DirectParserASTType type,
+ {this.partKeyword, this.ofKeyword, this.semicolon, this.hasName})
+ : super("PartOf", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "partKeyword": partKeyword,
+ "ofKeyword": ofKeyword,
+ "semicolon": semicolon,
+ "hasName": hasName,
+ };
+}
+
+class DirectParserASTContentRedirectingFactoryBodyBegin
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentRedirectingFactoryBodyBegin(DirectParserASTType type,
+ {this.token})
+ : super("RedirectingFactoryBody", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentRedirectingFactoryBodyEnd
+ extends DirectParserASTContent {
+ final Token beginToken;
+ final Token endToken;
+
+ DirectParserASTContentRedirectingFactoryBodyEnd(DirectParserASTType type,
+ {this.beginToken, this.endToken})
+ : super("RedirectingFactoryBody", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "beginToken": beginToken,
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentReturnStatementBegin
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentReturnStatementBegin(DirectParserASTType type,
+ {this.token})
+ : super("ReturnStatement", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentNativeFunctionBodyHandle
+ extends DirectParserASTContent {
+ final Token nativeToken;
+ final Token semicolon;
+
+ DirectParserASTContentNativeFunctionBodyHandle(DirectParserASTType type,
+ {this.nativeToken, this.semicolon})
+ : super("NativeFunctionBody", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "nativeToken": nativeToken,
+ "semicolon": semicolon,
+ };
+}
+
+class DirectParserASTContentNativeFunctionBodyIgnoredHandle
+ extends DirectParserASTContent {
+ final Token nativeToken;
+ final Token semicolon;
+
+ DirectParserASTContentNativeFunctionBodyIgnoredHandle(
+ DirectParserASTType type,
+ {this.nativeToken,
+ this.semicolon})
+ : super("NativeFunctionBodyIgnored", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "nativeToken": nativeToken,
+ "semicolon": semicolon,
+ };
+}
+
+class DirectParserASTContentNativeFunctionBodySkippedHandle
+ extends DirectParserASTContent {
+ final Token nativeToken;
+ final Token semicolon;
+
+ DirectParserASTContentNativeFunctionBodySkippedHandle(
+ DirectParserASTType type,
+ {this.nativeToken,
+ this.semicolon})
+ : super("NativeFunctionBodySkipped", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "nativeToken": nativeToken,
+ "semicolon": semicolon,
+ };
+}
+
+class DirectParserASTContentEmptyFunctionBodyHandle
+ extends DirectParserASTContent {
+ final Token semicolon;
+
+ DirectParserASTContentEmptyFunctionBodyHandle(DirectParserASTType type,
+ {this.semicolon})
+ : super("EmptyFunctionBody", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "semicolon": semicolon,
+ };
+}
+
+class DirectParserASTContentExpressionFunctionBodyHandle
+ extends DirectParserASTContent {
+ final Token arrowToken;
+ final Token endToken;
+
+ DirectParserASTContentExpressionFunctionBodyHandle(DirectParserASTType type,
+ {this.arrowToken, this.endToken})
+ : super("ExpressionFunctionBody", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "arrowToken": arrowToken,
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentReturnStatementEnd extends DirectParserASTContent {
+ final bool hasExpression;
+ final Token beginToken;
+ final Token endToken;
+
+ DirectParserASTContentReturnStatementEnd(DirectParserASTType type,
+ {this.hasExpression, this.beginToken, this.endToken})
+ : super("ReturnStatement", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "hasExpression": hasExpression,
+ "beginToken": beginToken,
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentSendHandle extends DirectParserASTContent {
+ final Token beginToken;
+ final Token endToken;
+
+ DirectParserASTContentSendHandle(DirectParserASTType type,
+ {this.beginToken, this.endToken})
+ : super("Send", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "beginToken": beginToken,
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentShowBegin extends DirectParserASTContent {
+ final Token showKeyword;
+
+ DirectParserASTContentShowBegin(DirectParserASTType type, {this.showKeyword})
+ : super("Show", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "showKeyword": showKeyword,
+ };
+}
+
+class DirectParserASTContentShowEnd extends DirectParserASTContent {
+ final Token showKeyword;
+
+ DirectParserASTContentShowEnd(DirectParserASTType type, {this.showKeyword})
+ : super("Show", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "showKeyword": showKeyword,
+ };
+}
+
+class DirectParserASTContentSwitchStatementBegin
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentSwitchStatementBegin(DirectParserASTType type,
+ {this.token})
+ : super("SwitchStatement", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentSwitchStatementEnd extends DirectParserASTContent {
+ final Token switchKeyword;
+ final Token endToken;
+
+ DirectParserASTContentSwitchStatementEnd(DirectParserASTType type,
+ {this.switchKeyword, this.endToken})
+ : super("SwitchStatement", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "switchKeyword": switchKeyword,
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentSwitchBlockBegin extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentSwitchBlockBegin(DirectParserASTType type, {this.token})
+ : super("SwitchBlock", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentSwitchBlockEnd extends DirectParserASTContent {
+ final int caseCount;
+ final Token beginToken;
+ final Token endToken;
+
+ DirectParserASTContentSwitchBlockEnd(DirectParserASTType type,
+ {this.caseCount, this.beginToken, this.endToken})
+ : super("SwitchBlock", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "caseCount": caseCount,
+ "beginToken": beginToken,
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentLiteralSymbolBegin extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentLiteralSymbolBegin(DirectParserASTType type,
+ {this.token})
+ : super("LiteralSymbol", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentLiteralSymbolEnd extends DirectParserASTContent {
+ final Token hashToken;
+ final int identifierCount;
+
+ DirectParserASTContentLiteralSymbolEnd(DirectParserASTType type,
+ {this.hashToken, this.identifierCount})
+ : super("LiteralSymbol", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "hashToken": hashToken,
+ "identifierCount": identifierCount,
+ };
+}
+
+class DirectParserASTContentThrowExpressionHandle
+ extends DirectParserASTContent {
+ final Token throwToken;
+ final Token endToken;
+
+ DirectParserASTContentThrowExpressionHandle(DirectParserASTType type,
+ {this.throwToken, this.endToken})
+ : super("ThrowExpression", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "throwToken": throwToken,
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentRethrowStatementBegin
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentRethrowStatementBegin(DirectParserASTType type,
+ {this.token})
+ : super("RethrowStatement", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentRethrowStatementEnd extends DirectParserASTContent {
+ final Token rethrowToken;
+ final Token endToken;
+
+ DirectParserASTContentRethrowStatementEnd(DirectParserASTType type,
+ {this.rethrowToken, this.endToken})
+ : super("RethrowStatement", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "rethrowToken": rethrowToken,
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentTopLevelDeclarationEnd
+ extends DirectParserASTContent {
+ final Token nextToken;
+
+ DirectParserASTContentTopLevelDeclarationEnd(DirectParserASTType type,
+ {this.nextToken})
+ : super("TopLevelDeclaration", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "nextToken": nextToken,
+ };
+}
+
+class DirectParserASTContentInvalidTopLevelDeclarationHandle
+ extends DirectParserASTContent {
+ final Token endToken;
+
+ DirectParserASTContentInvalidTopLevelDeclarationHandle(
+ DirectParserASTType type,
+ {this.endToken})
+ : super("InvalidTopLevelDeclaration", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentTopLevelMemberBegin extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentTopLevelMemberBegin(DirectParserASTType type,
+ {this.token})
+ : super("TopLevelMember", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentFieldsBegin extends DirectParserASTContent {
+ final Token lastConsumed;
+
+ DirectParserASTContentFieldsBegin(DirectParserASTType type,
+ {this.lastConsumed})
+ : super("Fields", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "lastConsumed": lastConsumed,
+ };
+}
+
+class DirectParserASTContentTopLevelFieldsEnd extends DirectParserASTContent {
+ final Token externalToken;
+ final Token staticToken;
+ final Token covariantToken;
+ final Token lateToken;
+ final Token varFinalOrConst;
+ final int count;
+ final Token beginToken;
+ final Token endToken;
+
+ DirectParserASTContentTopLevelFieldsEnd(DirectParserASTType type,
+ {this.externalToken,
+ this.staticToken,
+ this.covariantToken,
+ this.lateToken,
+ this.varFinalOrConst,
+ this.count,
+ this.beginToken,
+ this.endToken})
+ : super("TopLevelFields", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "externalToken": externalToken,
+ "staticToken": staticToken,
+ "covariantToken": covariantToken,
+ "lateToken": lateToken,
+ "varFinalOrConst": varFinalOrConst,
+ "count": count,
+ "beginToken": beginToken,
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentTopLevelMethodBegin extends DirectParserASTContent {
+ final Token lastConsumed;
+ final Token externalToken;
+
+ DirectParserASTContentTopLevelMethodBegin(DirectParserASTType type,
+ {this.lastConsumed, this.externalToken})
+ : super("TopLevelMethod", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "lastConsumed": lastConsumed,
+ "externalToken": externalToken,
+ };
+}
+
+class DirectParserASTContentTopLevelMethodEnd extends DirectParserASTContent {
+ final Token beginToken;
+ final Token getOrSet;
+ final Token endToken;
+
+ DirectParserASTContentTopLevelMethodEnd(DirectParserASTType type,
+ {this.beginToken, this.getOrSet, this.endToken})
+ : super("TopLevelMethod", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "beginToken": beginToken,
+ "getOrSet": getOrSet,
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentTryStatementBegin extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentTryStatementBegin(DirectParserASTType type,
+ {this.token})
+ : super("TryStatement", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentCaseMatchHandle extends DirectParserASTContent {
+ final Token caseKeyword;
+ final Token colon;
+
+ DirectParserASTContentCaseMatchHandle(DirectParserASTType type,
+ {this.caseKeyword, this.colon})
+ : super("CaseMatch", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "caseKeyword": caseKeyword,
+ "colon": colon,
+ };
+}
+
+class DirectParserASTContentCatchClauseBegin extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentCatchClauseBegin(DirectParserASTType type, {this.token})
+ : super("CatchClause", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentCatchClauseEnd extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentCatchClauseEnd(DirectParserASTType type, {this.token})
+ : super("CatchClause", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentCatchBlockHandle extends DirectParserASTContent {
+ final Token onKeyword;
+ final Token catchKeyword;
+ final Token comma;
+
+ DirectParserASTContentCatchBlockHandle(DirectParserASTType type,
+ {this.onKeyword, this.catchKeyword, this.comma})
+ : super("CatchBlock", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "onKeyword": onKeyword,
+ "catchKeyword": catchKeyword,
+ "comma": comma,
+ };
+}
+
+class DirectParserASTContentFinallyBlockHandle extends DirectParserASTContent {
+ final Token finallyKeyword;
+
+ DirectParserASTContentFinallyBlockHandle(DirectParserASTType type,
+ {this.finallyKeyword})
+ : super("FinallyBlock", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "finallyKeyword": finallyKeyword,
+ };
+}
+
+class DirectParserASTContentTryStatementEnd extends DirectParserASTContent {
+ final int catchCount;
+ final Token tryKeyword;
+ final Token finallyKeyword;
+
+ DirectParserASTContentTryStatementEnd(DirectParserASTType type,
+ {this.catchCount, this.tryKeyword, this.finallyKeyword})
+ : super("TryStatement", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "catchCount": catchCount,
+ "tryKeyword": tryKeyword,
+ "finallyKeyword": finallyKeyword,
+ };
+}
+
+class DirectParserASTContentTypeHandle extends DirectParserASTContent {
+ final Token beginToken;
+ final Token questionMark;
+
+ DirectParserASTContentTypeHandle(DirectParserASTType type,
+ {this.beginToken, this.questionMark})
+ : super("Type", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "beginToken": beginToken,
+ "questionMark": questionMark,
+ };
+}
+
+class DirectParserASTContentNonNullAssertExpressionHandle
+ extends DirectParserASTContent {
+ final Token bang;
+
+ DirectParserASTContentNonNullAssertExpressionHandle(DirectParserASTType type,
+ {this.bang})
+ : super("NonNullAssertExpression", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "bang": bang,
+ };
+}
+
+class DirectParserASTContentNoNameHandle extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentNoNameHandle(DirectParserASTType type, {this.token})
+ : super("NoName", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentFunctionTypeBegin extends DirectParserASTContent {
+ final Token beginToken;
+
+ DirectParserASTContentFunctionTypeBegin(DirectParserASTType type,
+ {this.beginToken})
+ : super("FunctionType", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "beginToken": beginToken,
+ };
+}
+
+class DirectParserASTContentFunctionTypeEnd extends DirectParserASTContent {
+ final Token functionToken;
+ final Token questionMark;
+
+ DirectParserASTContentFunctionTypeEnd(DirectParserASTType type,
+ {this.functionToken, this.questionMark})
+ : super("FunctionType", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "functionToken": functionToken,
+ "questionMark": questionMark,
+ };
+}
+
+class DirectParserASTContentTypeArgumentsBegin extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentTypeArgumentsBegin(DirectParserASTType type,
+ {this.token})
+ : super("TypeArguments", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentTypeArgumentsEnd extends DirectParserASTContent {
+ final int count;
+ final Token beginToken;
+ final Token endToken;
+
+ DirectParserASTContentTypeArgumentsEnd(DirectParserASTType type,
+ {this.count, this.beginToken, this.endToken})
+ : super("TypeArguments", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "count": count,
+ "beginToken": beginToken,
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentInvalidTypeArgumentsHandle
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentInvalidTypeArgumentsHandle(DirectParserASTType type,
+ {this.token})
+ : super("InvalidTypeArguments", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentNoTypeArgumentsHandle
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentNoTypeArgumentsHandle(DirectParserASTType type,
+ {this.token})
+ : super("NoTypeArguments", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentTypeVariableBegin extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentTypeVariableBegin(DirectParserASTType type,
+ {this.token})
+ : super("TypeVariable", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentTypeVariablesDefinedHandle
+ extends DirectParserASTContent {
+ final Token token;
+ final int count;
+
+ DirectParserASTContentTypeVariablesDefinedHandle(DirectParserASTType type,
+ {this.token, this.count})
+ : super("TypeVariablesDefined", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ "count": count,
+ };
+}
+
+class DirectParserASTContentTypeVariableEnd extends DirectParserASTContent {
+ final Token token;
+ final int index;
+ final Token extendsOrSuper;
+ final Token variance;
+
+ DirectParserASTContentTypeVariableEnd(DirectParserASTType type,
+ {this.token, this.index, this.extendsOrSuper, this.variance})
+ : super("TypeVariable", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ "index": index,
+ "extendsOrSuper": extendsOrSuper,
+ "variance": variance,
+ };
+}
+
+class DirectParserASTContentTypeVariablesBegin extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentTypeVariablesBegin(DirectParserASTType type,
+ {this.token})
+ : super("TypeVariables", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentTypeVariablesEnd extends DirectParserASTContent {
+ final Token beginToken;
+ final Token endToken;
+
+ DirectParserASTContentTypeVariablesEnd(DirectParserASTType type,
+ {this.beginToken, this.endToken})
+ : super("TypeVariables", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "beginToken": beginToken,
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentFunctionExpressionBegin
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentFunctionExpressionBegin(DirectParserASTType type,
+ {this.token})
+ : super("FunctionExpression", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentFunctionExpressionEnd
+ extends DirectParserASTContent {
+ final Token beginToken;
+ final Token token;
+
+ DirectParserASTContentFunctionExpressionEnd(DirectParserASTType type,
+ {this.beginToken, this.token})
+ : super("FunctionExpression", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "beginToken": beginToken,
+ "token": token,
+ };
+}
+
+class DirectParserASTContentVariablesDeclarationBegin
+ extends DirectParserASTContent {
+ final Token token;
+ final Token lateToken;
+ final Token varFinalOrConst;
+
+ DirectParserASTContentVariablesDeclarationBegin(DirectParserASTType type,
+ {this.token, this.lateToken, this.varFinalOrConst})
+ : super("VariablesDeclaration", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ "lateToken": lateToken,
+ "varFinalOrConst": varFinalOrConst,
+ };
+}
+
+class DirectParserASTContentVariablesDeclarationEnd
+ extends DirectParserASTContent {
+ final int count;
+ final Token endToken;
+
+ DirectParserASTContentVariablesDeclarationEnd(DirectParserASTType type,
+ {this.count, this.endToken})
+ : super("VariablesDeclaration", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "count": count,
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentWhileStatementBegin extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentWhileStatementBegin(DirectParserASTType type,
+ {this.token})
+ : super("WhileStatement", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentWhileStatementEnd extends DirectParserASTContent {
+ final Token whileKeyword;
+ final Token endToken;
+
+ DirectParserASTContentWhileStatementEnd(DirectParserASTType type,
+ {this.whileKeyword, this.endToken})
+ : super("WhileStatement", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "whileKeyword": whileKeyword,
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentAsOperatorTypeBegin extends DirectParserASTContent {
+ final Token operator;
+
+ DirectParserASTContentAsOperatorTypeBegin(DirectParserASTType type,
+ {this.operator})
+ : super("AsOperatorType", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "operator": operator,
+ };
+}
+
+class DirectParserASTContentAsOperatorTypeEnd extends DirectParserASTContent {
+ final Token operator;
+
+ DirectParserASTContentAsOperatorTypeEnd(DirectParserASTType type,
+ {this.operator})
+ : super("AsOperatorType", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "operator": operator,
+ };
+}
+
+class DirectParserASTContentAsOperatorHandle extends DirectParserASTContent {
+ final Token operator;
+
+ DirectParserASTContentAsOperatorHandle(DirectParserASTType type,
+ {this.operator})
+ : super("AsOperator", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "operator": operator,
+ };
+}
+
+class DirectParserASTContentAssignmentExpressionHandle
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentAssignmentExpressionHandle(DirectParserASTType type,
+ {this.token})
+ : super("AssignmentExpression", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentBinaryExpressionBegin
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentBinaryExpressionBegin(DirectParserASTType type,
+ {this.token})
+ : super("BinaryExpression", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentBinaryExpressionEnd extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentBinaryExpressionEnd(DirectParserASTType type,
+ {this.token})
+ : super("BinaryExpression", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentEndingBinaryExpressionHandle
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentEndingBinaryExpressionHandle(DirectParserASTType type,
+ {this.token})
+ : super("EndingBinaryExpression", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentConditionalExpressionBegin
+ extends DirectParserASTContent {
+ final Token question;
+
+ DirectParserASTContentConditionalExpressionBegin(DirectParserASTType type,
+ {this.question})
+ : super("ConditionalExpression", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "question": question,
+ };
+}
+
+class DirectParserASTContentConditionalExpressionColonHandle
+ extends DirectParserASTContent {
+ DirectParserASTContentConditionalExpressionColonHandle(
+ DirectParserASTType type)
+ : super("ConditionalExpressionColon", type);
+
+ Map<String, Object> get deprecatedArguments => {};
+}
+
+class DirectParserASTContentConditionalExpressionEnd
+ extends DirectParserASTContent {
+ final Token question;
+ final Token colon;
+
+ DirectParserASTContentConditionalExpressionEnd(DirectParserASTType type,
+ {this.question, this.colon})
+ : super("ConditionalExpression", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "question": question,
+ "colon": colon,
+ };
+}
+
+class DirectParserASTContentConstExpressionBegin
+ extends DirectParserASTContent {
+ final Token constKeyword;
+
+ DirectParserASTContentConstExpressionBegin(DirectParserASTType type,
+ {this.constKeyword})
+ : super("ConstExpression", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "constKeyword": constKeyword,
+ };
+}
+
+class DirectParserASTContentConstExpressionEnd extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentConstExpressionEnd(DirectParserASTType type,
+ {this.token})
+ : super("ConstExpression", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentForControlFlowBegin extends DirectParserASTContent {
+ final Token awaitToken;
+ final Token forToken;
+
+ DirectParserASTContentForControlFlowBegin(DirectParserASTType type,
+ {this.awaitToken, this.forToken})
+ : super("ForControlFlow", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "awaitToken": awaitToken,
+ "forToken": forToken,
+ };
+}
+
+class DirectParserASTContentForControlFlowEnd extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentForControlFlowEnd(DirectParserASTType type,
+ {this.token})
+ : super("ForControlFlow", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentForInControlFlowEnd extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentForInControlFlowEnd(DirectParserASTType type,
+ {this.token})
+ : super("ForInControlFlow", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentIfControlFlowBegin extends DirectParserASTContent {
+ final Token ifToken;
+
+ DirectParserASTContentIfControlFlowBegin(DirectParserASTType type,
+ {this.ifToken})
+ : super("IfControlFlow", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "ifToken": ifToken,
+ };
+}
+
+class DirectParserASTContentThenControlFlowHandle
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentThenControlFlowHandle(DirectParserASTType type,
+ {this.token})
+ : super("ThenControlFlow", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentElseControlFlowHandle
+ extends DirectParserASTContent {
+ final Token elseToken;
+
+ DirectParserASTContentElseControlFlowHandle(DirectParserASTType type,
+ {this.elseToken})
+ : super("ElseControlFlow", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "elseToken": elseToken,
+ };
+}
+
+class DirectParserASTContentIfControlFlowEnd extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentIfControlFlowEnd(DirectParserASTType type, {this.token})
+ : super("IfControlFlow", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentIfElseControlFlowEnd
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentIfElseControlFlowEnd(DirectParserASTType type,
+ {this.token})
+ : super("IfElseControlFlow", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentSpreadExpressionHandle
+ extends DirectParserASTContent {
+ final Token spreadToken;
+
+ DirectParserASTContentSpreadExpressionHandle(DirectParserASTType type,
+ {this.spreadToken})
+ : super("SpreadExpression", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "spreadToken": spreadToken,
+ };
+}
+
+class DirectParserASTContentFunctionTypedFormalParameterBegin
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentFunctionTypedFormalParameterBegin(
+ DirectParserASTType type,
+ {this.token})
+ : super("FunctionTypedFormalParameter", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentFunctionTypedFormalParameterEnd
+ extends DirectParserASTContent {
+ final Token nameToken;
+ final Token question;
+
+ DirectParserASTContentFunctionTypedFormalParameterEnd(
+ DirectParserASTType type,
+ {this.nameToken,
+ this.question})
+ : super("FunctionTypedFormalParameter", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "nameToken": nameToken,
+ "question": question,
+ };
+}
+
+class DirectParserASTContentIdentifierHandle extends DirectParserASTContent {
+ final Token token;
+ final IdentifierContext context;
+
+ DirectParserASTContentIdentifierHandle(DirectParserASTType type,
+ {this.token, this.context})
+ : super("Identifier", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ "context": context,
+ };
+}
+
+class DirectParserASTContentIndexedExpressionHandle
+ extends DirectParserASTContent {
+ final Token question;
+ final Token openSquareBracket;
+ final Token closeSquareBracket;
+
+ DirectParserASTContentIndexedExpressionHandle(DirectParserASTType type,
+ {this.question, this.openSquareBracket, this.closeSquareBracket})
+ : super("IndexedExpression", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "question": question,
+ "openSquareBracket": openSquareBracket,
+ "closeSquareBracket": closeSquareBracket,
+ };
+}
+
+class DirectParserASTContentIsOperatorTypeBegin extends DirectParserASTContent {
+ final Token operator;
+
+ DirectParserASTContentIsOperatorTypeBegin(DirectParserASTType type,
+ {this.operator})
+ : super("IsOperatorType", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "operator": operator,
+ };
+}
+
+class DirectParserASTContentIsOperatorTypeEnd extends DirectParserASTContent {
+ final Token operator;
+
+ DirectParserASTContentIsOperatorTypeEnd(DirectParserASTType type,
+ {this.operator})
+ : super("IsOperatorType", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "operator": operator,
+ };
+}
+
+class DirectParserASTContentIsOperatorHandle extends DirectParserASTContent {
+ final Token isOperator;
+ final Token not;
+
+ DirectParserASTContentIsOperatorHandle(DirectParserASTType type,
+ {this.isOperator, this.not})
+ : super("IsOperator", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "isOperator": isOperator,
+ "not": not,
+ };
+}
+
+class DirectParserASTContentLiteralBoolHandle extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentLiteralBoolHandle(DirectParserASTType type,
+ {this.token})
+ : super("LiteralBool", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentBreakStatementHandle
+ extends DirectParserASTContent {
+ final bool hasTarget;
+ final Token breakKeyword;
+ final Token endToken;
+
+ DirectParserASTContentBreakStatementHandle(DirectParserASTType type,
+ {this.hasTarget, this.breakKeyword, this.endToken})
+ : super("BreakStatement", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "hasTarget": hasTarget,
+ "breakKeyword": breakKeyword,
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentContinueStatementHandle
+ extends DirectParserASTContent {
+ final bool hasTarget;
+ final Token continueKeyword;
+ final Token endToken;
+
+ DirectParserASTContentContinueStatementHandle(DirectParserASTType type,
+ {this.hasTarget, this.continueKeyword, this.endToken})
+ : super("ContinueStatement", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "hasTarget": hasTarget,
+ "continueKeyword": continueKeyword,
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentEmptyStatementHandle
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentEmptyStatementHandle(DirectParserASTType type,
+ {this.token})
+ : super("EmptyStatement", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentAssertBegin extends DirectParserASTContent {
+ final Token assertKeyword;
+ final Assert kind;
+
+ DirectParserASTContentAssertBegin(DirectParserASTType type,
+ {this.assertKeyword, this.kind})
+ : super("Assert", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "assertKeyword": assertKeyword,
+ "kind": kind,
+ };
+}
+
+class DirectParserASTContentAssertEnd extends DirectParserASTContent {
+ final Token assertKeyword;
+ final Assert kind;
+ final Token leftParenthesis;
+ final Token commaToken;
+ final Token semicolonToken;
+
+ DirectParserASTContentAssertEnd(DirectParserASTType type,
+ {this.assertKeyword,
+ this.kind,
+ this.leftParenthesis,
+ this.commaToken,
+ this.semicolonToken})
+ : super("Assert", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "assertKeyword": assertKeyword,
+ "kind": kind,
+ "leftParenthesis": leftParenthesis,
+ "commaToken": commaToken,
+ "semicolonToken": semicolonToken,
+ };
+}
+
+class DirectParserASTContentLiteralDoubleHandle extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentLiteralDoubleHandle(DirectParserASTType type,
+ {this.token})
+ : super("LiteralDouble", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentLiteralIntHandle extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentLiteralIntHandle(DirectParserASTType type, {this.token})
+ : super("LiteralInt", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentLiteralListHandle extends DirectParserASTContent {
+ final int count;
+ final Token leftBracket;
+ final Token constKeyword;
+ final Token rightBracket;
+
+ DirectParserASTContentLiteralListHandle(DirectParserASTType type,
+ {this.count, this.leftBracket, this.constKeyword, this.rightBracket})
+ : super("LiteralList", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "count": count,
+ "leftBracket": leftBracket,
+ "constKeyword": constKeyword,
+ "rightBracket": rightBracket,
+ };
+}
+
+class DirectParserASTContentLiteralSetOrMapHandle
+ extends DirectParserASTContent {
+ final int count;
+ final Token leftBrace;
+ final Token constKeyword;
+ final Token rightBrace;
+ final bool hasSetEntry;
+
+ DirectParserASTContentLiteralSetOrMapHandle(DirectParserASTType type,
+ {this.count,
+ this.leftBrace,
+ this.constKeyword,
+ this.rightBrace,
+ this.hasSetEntry})
+ : super("LiteralSetOrMap", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "count": count,
+ "leftBrace": leftBrace,
+ "constKeyword": constKeyword,
+ "rightBrace": rightBrace,
+ "hasSetEntry": hasSetEntry,
+ };
+}
+
+class DirectParserASTContentLiteralNullHandle extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentLiteralNullHandle(DirectParserASTType type,
+ {this.token})
+ : super("LiteralNull", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentNativeClauseHandle extends DirectParserASTContent {
+ final Token nativeToken;
+ final bool hasName;
+
+ DirectParserASTContentNativeClauseHandle(DirectParserASTType type,
+ {this.nativeToken, this.hasName})
+ : super("NativeClause", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "nativeToken": nativeToken,
+ "hasName": hasName,
+ };
+}
+
+class DirectParserASTContentNamedArgumentHandle extends DirectParserASTContent {
+ final Token colon;
+
+ DirectParserASTContentNamedArgumentHandle(DirectParserASTType type,
+ {this.colon})
+ : super("NamedArgument", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "colon": colon,
+ };
+}
+
+class DirectParserASTContentNewExpressionBegin extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentNewExpressionBegin(DirectParserASTType type,
+ {this.token})
+ : super("NewExpression", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentNewExpressionEnd extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentNewExpressionEnd(DirectParserASTType type, {this.token})
+ : super("NewExpression", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentNoArgumentsHandle extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentNoArgumentsHandle(DirectParserASTType type,
+ {this.token})
+ : super("NoArguments", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentNoConstructorReferenceContinuationAfterTypeArgumentsHandle
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentNoConstructorReferenceContinuationAfterTypeArgumentsHandle(
+ DirectParserASTType type,
+ {this.token})
+ : super("NoConstructorReferenceContinuationAfterTypeArguments", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentNoTypeHandle extends DirectParserASTContent {
+ final Token lastConsumed;
+
+ DirectParserASTContentNoTypeHandle(DirectParserASTType type,
+ {this.lastConsumed})
+ : super("NoType", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "lastConsumed": lastConsumed,
+ };
+}
+
+class DirectParserASTContentNoTypeVariablesHandle
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentNoTypeVariablesHandle(DirectParserASTType type,
+ {this.token})
+ : super("NoTypeVariables", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentOperatorHandle extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentOperatorHandle(DirectParserASTType type, {this.token})
+ : super("Operator", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentSymbolVoidHandle extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentSymbolVoidHandle(DirectParserASTType type, {this.token})
+ : super("SymbolVoid", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentOperatorNameHandle extends DirectParserASTContent {
+ final Token operatorKeyword;
+ final Token token;
+
+ DirectParserASTContentOperatorNameHandle(DirectParserASTType type,
+ {this.operatorKeyword, this.token})
+ : super("OperatorName", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "operatorKeyword": operatorKeyword,
+ "token": token,
+ };
+}
+
+class DirectParserASTContentInvalidOperatorNameHandle
+ extends DirectParserASTContent {
+ final Token operatorKeyword;
+ final Token token;
+
+ DirectParserASTContentInvalidOperatorNameHandle(DirectParserASTType type,
+ {this.operatorKeyword, this.token})
+ : super("InvalidOperatorName", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "operatorKeyword": operatorKeyword,
+ "token": token,
+ };
+}
+
+class DirectParserASTContentParenthesizedConditionHandle
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentParenthesizedConditionHandle(DirectParserASTType type,
+ {this.token})
+ : super("ParenthesizedCondition", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentParenthesizedExpressionHandle
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentParenthesizedExpressionHandle(DirectParserASTType type,
+ {this.token})
+ : super("ParenthesizedExpression", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentQualifiedHandle extends DirectParserASTContent {
+ final Token period;
+
+ DirectParserASTContentQualifiedHandle(DirectParserASTType type, {this.period})
+ : super("Qualified", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "period": period,
+ };
+}
+
+class DirectParserASTContentStringPartHandle extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentStringPartHandle(DirectParserASTType type, {this.token})
+ : super("StringPart", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentSuperExpressionHandle
+ extends DirectParserASTContent {
+ final Token token;
+ final IdentifierContext context;
+
+ DirectParserASTContentSuperExpressionHandle(DirectParserASTType type,
+ {this.token, this.context})
+ : super("SuperExpression", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ "context": context,
+ };
+}
+
+class DirectParserASTContentSwitchCaseBegin extends DirectParserASTContent {
+ final int labelCount;
+ final int expressionCount;
+ final Token firstToken;
+
+ DirectParserASTContentSwitchCaseBegin(DirectParserASTType type,
+ {this.labelCount, this.expressionCount, this.firstToken})
+ : super("SwitchCase", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "labelCount": labelCount,
+ "expressionCount": expressionCount,
+ "firstToken": firstToken,
+ };
+}
+
+class DirectParserASTContentSwitchCaseEnd extends DirectParserASTContent {
+ final int labelCount;
+ final int expressionCount;
+ final Token defaultKeyword;
+ final Token colonAfterDefault;
+ final int statementCount;
+ final Token firstToken;
+ final Token endToken;
+
+ DirectParserASTContentSwitchCaseEnd(DirectParserASTType type,
+ {this.labelCount,
+ this.expressionCount,
+ this.defaultKeyword,
+ this.colonAfterDefault,
+ this.statementCount,
+ this.firstToken,
+ this.endToken})
+ : super("SwitchCase", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "labelCount": labelCount,
+ "expressionCount": expressionCount,
+ "defaultKeyword": defaultKeyword,
+ "colonAfterDefault": colonAfterDefault,
+ "statementCount": statementCount,
+ "firstToken": firstToken,
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentThisExpressionHandle
+ extends DirectParserASTContent {
+ final Token token;
+ final IdentifierContext context;
+
+ DirectParserASTContentThisExpressionHandle(DirectParserASTType type,
+ {this.token, this.context})
+ : super("ThisExpression", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ "context": context,
+ };
+}
+
+class DirectParserASTContentUnaryPostfixAssignmentExpressionHandle
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentUnaryPostfixAssignmentExpressionHandle(
+ DirectParserASTType type,
+ {this.token})
+ : super("UnaryPostfixAssignmentExpression", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentUnaryPrefixExpressionHandle
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentUnaryPrefixExpressionHandle(DirectParserASTType type,
+ {this.token})
+ : super("UnaryPrefixExpression", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentUnaryPrefixAssignmentExpressionHandle
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentUnaryPrefixAssignmentExpressionHandle(
+ DirectParserASTType type,
+ {this.token})
+ : super("UnaryPrefixAssignmentExpression", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentFormalParameterDefaultValueExpressionBegin
+ extends DirectParserASTContent {
+ DirectParserASTContentFormalParameterDefaultValueExpressionBegin(
+ DirectParserASTType type)
+ : super("FormalParameterDefaultValueExpression", type);
+
+ Map<String, Object> get deprecatedArguments => {};
+}
+
+class DirectParserASTContentFormalParameterDefaultValueExpressionEnd
+ extends DirectParserASTContent {
+ DirectParserASTContentFormalParameterDefaultValueExpressionEnd(
+ DirectParserASTType type)
+ : super("FormalParameterDefaultValueExpression", type);
+
+ Map<String, Object> get deprecatedArguments => {};
+}
+
+class DirectParserASTContentValuedFormalParameterHandle
+ extends DirectParserASTContent {
+ final Token equals;
+ final Token token;
+
+ DirectParserASTContentValuedFormalParameterHandle(DirectParserASTType type,
+ {this.equals, this.token})
+ : super("ValuedFormalParameter", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "equals": equals,
+ "token": token,
+ };
+}
+
+class DirectParserASTContentFormalParameterWithoutValueHandle
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentFormalParameterWithoutValueHandle(
+ DirectParserASTType type,
+ {this.token})
+ : super("FormalParameterWithoutValue", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentVoidKeywordHandle extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentVoidKeywordHandle(DirectParserASTType type,
+ {this.token})
+ : super("VoidKeyword", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentVoidKeywordWithTypeArgumentsHandle
+ extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentVoidKeywordWithTypeArgumentsHandle(
+ DirectParserASTType type,
+ {this.token})
+ : super("VoidKeywordWithTypeArguments", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentYieldStatementBegin extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentYieldStatementBegin(DirectParserASTType type,
+ {this.token})
+ : super("YieldStatement", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentYieldStatementEnd extends DirectParserASTContent {
+ final Token yieldToken;
+ final Token starToken;
+ final Token endToken;
+
+ DirectParserASTContentYieldStatementEnd(DirectParserASTType type,
+ {this.yieldToken, this.starToken, this.endToken})
+ : super("YieldStatement", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "yieldToken": yieldToken,
+ "starToken": starToken,
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentInvalidYieldStatementEnd
+ extends DirectParserASTContent {
+ final Token beginToken;
+ final Token starToken;
+ final Token endToken;
+ final MessageCode errorCode;
+
+ DirectParserASTContentInvalidYieldStatementEnd(DirectParserASTType type,
+ {this.beginToken, this.starToken, this.endToken, this.errorCode})
+ : super("InvalidYieldStatement", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "beginToken": beginToken,
+ "starToken": starToken,
+ "endToken": endToken,
+ "errorCode": errorCode,
+ };
+}
+
+class DirectParserASTContentRecoverableErrorHandle
+ extends DirectParserASTContent {
+ final Message message;
+ final Token startToken;
+ final Token endToken;
+
+ DirectParserASTContentRecoverableErrorHandle(DirectParserASTType type,
+ {this.message, this.startToken, this.endToken})
+ : super("RecoverableError", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "message": message,
+ "startToken": startToken,
+ "endToken": endToken,
+ };
+}
+
+class DirectParserASTContentErrorTokenHandle extends DirectParserASTContent {
+ final ErrorToken token;
+
+ DirectParserASTContentErrorTokenHandle(DirectParserASTType type, {this.token})
+ : super("ErrorToken", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentUnescapeErrorHandle extends DirectParserASTContent {
+ final Message message;
+ final Token location;
+ final int stringOffset;
+ final int length;
+
+ DirectParserASTContentUnescapeErrorHandle(DirectParserASTType type,
+ {this.message, this.location, this.stringOffset, this.length})
+ : super("UnescapeError", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "message": message,
+ "location": location,
+ "stringOffset": stringOffset,
+ "length": length,
+ };
+}
+
+class DirectParserASTContentInvalidStatementHandle
+ extends DirectParserASTContent {
+ final Token token;
+ final Message message;
+
+ DirectParserASTContentInvalidStatementHandle(DirectParserASTType type,
+ {this.token, this.message})
+ : super("InvalidStatement", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ "message": message,
+ };
+}
+
+class DirectParserASTContentScriptHandle extends DirectParserASTContent {
+ final Token token;
+
+ DirectParserASTContentScriptHandle(DirectParserASTType type, {this.token})
+ : super("Script", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "token": token,
+ };
+}
+
+class DirectParserASTContentCommentReferenceTextHandle
+ extends DirectParserASTContent {
+ final String referenceSource;
+ final int referenceOffset;
+
+ DirectParserASTContentCommentReferenceTextHandle(DirectParserASTType type,
+ {this.referenceSource, this.referenceOffset})
+ : super("CommentReferenceText", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "referenceSource": referenceSource,
+ "referenceOffset": referenceOffset,
+ };
+}
+
+class DirectParserASTContentCommentReferenceHandle
+ extends DirectParserASTContent {
+ final Token newKeyword;
+ final Token prefix;
+ final Token period;
+ final Token token;
+
+ DirectParserASTContentCommentReferenceHandle(DirectParserASTType type,
+ {this.newKeyword, this.prefix, this.period, this.token})
+ : super("CommentReference", type);
+
+ Map<String, Object> get deprecatedArguments => {
+ "newKeyword": newKeyword,
+ "prefix": prefix,
+ "period": period,
+ "token": token,
+ };
+}
+
+class DirectParserASTContentNoCommentReferenceHandle
+ extends DirectParserASTContent {
+ DirectParserASTContentNoCommentReferenceHandle(DirectParserASTType type)
+ : super("NoCommentReference", type);
+
+ Map<String, Object> get deprecatedArguments => {};
+}
diff --git a/pkg/front_end/test/spell_checking_list_code.txt b/pkg/front_end/test/spell_checking_list_code.txt
index 8c1ad37..e504875 100644
--- a/pkg/front_end/test/spell_checking_list_code.txt
+++ b/pkg/front_end/test/spell_checking_list_code.txt
@@ -113,6 +113,7 @@
bit2
bj
bk
+blindly
blob
blocking
bmp
diff --git a/pkg/front_end/test/spell_checking_list_tests.txt b/pkg/front_end/test/spell_checking_list_tests.txt
index 6d17e58..d4f79ca 100644
--- a/pkg/front_end/test/spell_checking_list_tests.txt
+++ b/pkg/front_end/test/spell_checking_list_tests.txt
@@ -292,6 +292,7 @@
forty
foundation
fox
+frozen
fulfill
func
futures
@@ -460,6 +461,7 @@
mul
mx
mysdk
+naively
naturally
negatable
newworld
@@ -698,6 +700,7 @@
unversioned
upload
upward
+usages
uses8
uuid
v1
diff --git a/pkg/front_end/tool/_fasta/direct_parser_ast_helper_creator.dart b/pkg/front_end/tool/_fasta/direct_parser_ast_helper_creator.dart
index 2153705..8b7cf18 100644
--- a/pkg/front_end/tool/_fasta/direct_parser_ast_helper_creator.dart
+++ b/pkg/front_end/tool/_fasta/direct_parser_ast_helper_creator.dart
@@ -48,6 +48,8 @@
import 'package:_fe_analyzer_shared/src/scanner/token.dart';
import 'package:front_end/src/fasta/messages.dart';
+// ignore_for_file: lines_longer_than_80_chars
+
// THIS FILE IS AUTO GENERATED BY
// 'tool/_fasta/direct_parser_ast_helper_creator.dart'
// Run e.g.
@@ -57,23 +59,23 @@
> pkg/front_end/lib/src/fasta/util/direct_parser_ast_helper.dart
*/
-class DirectParserASTContent {
+abstract class DirectParserASTContent {
final String what;
final DirectParserASTType type;
- final Map<String, Object> arguments;
- List<DirectParserASTContent> content;
+ Map<String, Object> get deprecatedArguments;
+ List<DirectParserASTContent> children;
- DirectParserASTContent(this.what, this.type, this.arguments);
+ DirectParserASTContent(this.what, this.type);
// TODO(jensj): Compare two ASTs.
}
-enum DirectParserASTType { BEGIN, END, HANDLE, DONE }
+enum DirectParserASTType { BEGIN, END, HANDLE }
abstract class AbstractDirectParserASTListener implements Listener {
List<DirectParserASTContent> data = [];
- void seen(String what, DirectParserASTType type, Map<String, Object> arguments);
+ void seen(DirectParserASTContent entry);
""");
@@ -82,6 +84,8 @@
parser.parseUnit(firstToken);
out.writeln("}");
+ out.writeln("");
+ out.write(listener.newClasses.toString());
if (out is StringBuffer) {
String text = new DartFormatter().format("$out");
@@ -99,6 +103,7 @@
String latestSeenParameterTypeToken;
List<String> parameters = <String>[];
List<String> parameterTypes = <String>[];
+ StringBuffer newClasses = new StringBuffer();
void beginClassDeclaration(Token begin, Token abstractToken, Token name) {
if (name.lexeme == "Listener") insideListenerClass = true;
@@ -150,39 +155,79 @@
return end();
} else {
sb.write("\n ");
- sb.write('seen("');
String typeString;
+ String typeStringCamel;
String name;
if (currentMethodName.startsWith("begin")) {
typeString = "BEGIN";
+ typeStringCamel = "Begin";
name = currentMethodName.substring("begin".length);
} else if (currentMethodName.startsWith("end")) {
typeString = "END";
+ typeStringCamel = "End";
name = currentMethodName.substring("end".length);
} else if (currentMethodName.startsWith("handle")) {
typeString = "HANDLE";
+ typeStringCamel = "Handle";
name = currentMethodName.substring("handle".length);
} else {
throw "Unexpected.";
}
- sb.write(name);
- sb.write('", DirectParserASTType.');
+
+ String className = "DirectParserASTContent${name}${typeStringCamel}";
+ sb.write("$className data = new $className(");
+ sb.write("DirectParserASTType.");
sb.write(typeString);
- sb.write(", {");
- String separator = "";
for (int i = 0; i < parameters.length; i++) {
- sb.write(separator);
- sb.write('"');
+ sb.write(', ');
sb.write(parameters[i]);
- sb.write('": ');
+ sb.write(': ');
sb.write(parameters[i]);
- separator = ", ";
}
- sb.write("});\n ");
+ sb.write(");");
+ sb.write("\n ");
+ sb.write("seen(data);");
+ sb.write("\n ");
- sb.write("}");
+ newClasses
+ .write("class DirectParserASTContent${name}${typeStringCamel} "
+ "extends DirectParserASTContent {\n");
+
+ for (int i = 0; i < parameters.length; i++) {
+ newClasses.write(" final ");
+ newClasses.write(parameterTypes[i]);
+ newClasses.write(' ');
+ newClasses.write(parameters[i]);
+ newClasses.write(';\n');
+ }
+ newClasses.write('\n');
+ newClasses.write(" DirectParserASTContent${name}${typeStringCamel}"
+ "(DirectParserASTType type");
+ String separator = ", {";
+ for (int i = 0; i < parameters.length; i++) {
+ newClasses.write(separator);
+ newClasses.write('this.');
+ newClasses.write(parameters[i]);
+ separator = ", ";
+ }
+ if (parameters.isNotEmpty) {
+ newClasses.write('}');
+ }
+ newClasses.write(') : super("$name", type);\n\n');
+ newClasses.write("Map<String, Object> get deprecatedArguments => {");
+ for (int i = 0; i < parameters.length; i++) {
+ newClasses.write('"');
+ newClasses.write(parameters[i]);
+ newClasses.write('": ');
+ newClasses.write(parameters[i]);
+ newClasses.write(',');
+ }
+ newClasses.write("};\n");
+ newClasses.write("}\n");
}
+
+ sb.write("}");
sb.write("\n\n");
out.write(sb.toString());
diff --git a/pkg/front_end/tool/kernel_ast_file_rewriter.dart b/pkg/front_end/tool/kernel_ast_file_rewriter.dart
new file mode 100644
index 0000000..35c5daa
--- /dev/null
+++ b/pkg/front_end/tool/kernel_ast_file_rewriter.dart
@@ -0,0 +1,429 @@
+// Copyright (c) 2020, 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 "dart:io" show File, Platform, stdout;
+import "dart:typed_data" show Uint8List;
+
+import 'package:_fe_analyzer_shared/src/scanner/token.dart';
+import 'package:analyzer/dart/ast/token.dart';
+import "package:front_end/src/fasta/util/direct_parser_ast.dart";
+import "package:front_end/src/fasta/util/direct_parser_ast_helper.dart"
+ show DirectParserASTContent;
+import 'package:_fe_analyzer_shared/src/parser/parser.dart'
+ show IdentifierContext;
+import 'package:front_end/src/fasta/util/direct_parser_ast_helper.dart';
+
+void main(List<String> args) {
+ Uri uri = Platform.script;
+ uri = uri.resolve("../../kernel/lib/ast.dart");
+ Uint8List bytes = new File.fromUri(uri).readAsBytesSync();
+ DirectParserASTContentCompilationUnitEnd ast =
+ getAST(bytes, includeBody: true, includeComments: true);
+ Map<String, DirectParserASTContentTopLevelDeclarationEnd> classes = {};
+ for (DirectParserASTContentTopLevelDeclarationEnd cls in ast.getClasses()) {
+ DirectParserASTContentIdentifierHandle identifier =
+ cls.getClassIdentifier();
+ assert(classes[identifier.token] == null);
+ classes[identifier.token.toString()] = cls;
+ }
+
+ Set<String> goodNames = {"TreeNode"};
+ Map<Token, Replacement> replacements = {};
+ for (MapEntry<String, DirectParserASTContentTopLevelDeclarationEnd> entry
+ in classes.entries) {
+ DirectParserASTContentTopLevelDeclarationEnd cls = entry.value;
+
+ // Simple "class hierarchy" to only work on TreeNodes.
+ if (goodNames.contains(entry.key)) {
+ // Cached good.
+ } else {
+ // Check if good.
+ String parent = getExtends(cls);
+ DirectParserASTContentTopLevelDeclarationEnd parentCls = classes[parent];
+ List<String> allParents = [parent];
+ while (
+ parent != null && parentCls != null && !goodNames.contains(parent)) {
+ parent = getExtends(parentCls);
+ allParents.add(parent);
+ parentCls = classes[parent];
+ }
+ if (goodNames.contains(parent)) {
+ goodNames.addAll(allParents);
+ } else {
+ continue;
+ }
+ }
+
+ DirectParserASTContentClassDeclarationEnd classDeclaration =
+ cls.getClassDeclaration();
+ DirectParserASTContentClassOrMixinBodyEnd classOrMixinBody =
+ classDeclaration.getClassOrMixinBody();
+
+ Set<String> namedClassConstructors = {};
+ Set<String> namedFields = {};
+ for (DirectParserASTContentMemberEnd member
+ in classOrMixinBody.getMembers()) {
+ if (member.isClassConstructor()) {
+ DirectParserASTContentClassConstructorEnd constructor =
+ member.getClassConstructor();
+ Token nameToken = constructor.beginToken;
+ // String name = nameToken.lexeme;
+ if (nameToken.next.lexeme == ".") {
+ nameToken = nameToken.next.next;
+ // name += ".$nameToken";
+ namedClassConstructors.add(nameToken.lexeme);
+ }
+ if (nameToken.next.lexeme == ".") {
+ throw "Unexpected";
+ }
+ } else if (member.isClassFields()) {
+ DirectParserASTContentClassFieldsEnd classFields =
+ member.getClassFields();
+ Token identifierToken = classFields.getFieldIdentifiers().single.token;
+ String identifier = identifierToken.toString();
+ namedFields.add(identifier);
+ }
+ }
+
+ // If there isn't a `frozen` field in `TreeNode` we insert one.
+ if (entry.key == "TreeNode" && !namedFields.contains("frozen")) {
+ Token classBraceToken = classOrMixinBody.beginToken;
+ assert(classBraceToken.lexeme == "{");
+ replacements[classBraceToken] = new Replacement(
+ classBraceToken, classBraceToken, "{\n bool frozen = false;");
+ }
+
+ for (DirectParserASTContentMemberEnd member
+ in classOrMixinBody.getMembers()) {
+ if (member.isClassConstructor()) {
+ processConstructor(
+ member, replacements, namedClassConstructors, namedFields);
+ } else if (member.isClassFields()) {
+ processField(member, entry, replacements);
+ }
+ }
+ }
+ Token token = ast.getBegin().token;
+
+ int endOfLast = token.end;
+ while (token != null) {
+ CommentToken comment = token.precedingComments;
+ while (comment != null) {
+ if (comment.offset > endOfLast) {
+ for (int i = endOfLast; i < comment.offset; i++) {
+ int byte = bytes[i];
+ stdout.writeCharCode(byte);
+ }
+ }
+
+ stdout.write(comment.value());
+ endOfLast = comment.end;
+ comment = comment.next;
+ }
+
+ if (token.isEof) break;
+ if (token.offset > endOfLast) {
+ for (int i = endOfLast; i < token.offset; i++) {
+ int byte = bytes[i];
+ stdout.writeCharCode(byte);
+ }
+ }
+
+ Replacement replacement = replacements[token];
+ if (replacement != null) {
+ stdout.write(replacement.replacement);
+ token = replacement.endToken;
+ } else {
+ stdout.write(token.lexeme);
+ }
+ endOfLast = token.end;
+ token = token.next;
+ }
+}
+
+void processField(
+ DirectParserASTContentMemberEnd member,
+ MapEntry<String, DirectParserASTContentTopLevelDeclarationEnd> entry,
+ Map<Token, Replacement> replacements) {
+ DirectParserASTContentClassFieldsEnd classFields = member.getClassFields();
+
+ if (classFields.count != 1) {
+ throw "Notice ${classFields.count}";
+ }
+
+ Token identifierToken = classFields.getFieldIdentifiers().single.token;
+ String identifier = identifierToken.toString();
+
+ if (identifier == "frozen" && entry.key == "TreeNode") return;
+
+ if (classFields.staticToken != null) {
+ return;
+ }
+ bool isFinal = false;
+ if (classFields.varFinalOrConst?.toString() == "final") {
+ isFinal = true;
+ }
+
+ DirectParserASTContentTypeHandle type = classFields.getFirstType();
+ String typeString = "dynamic";
+ if (type != null) {
+ Token token = type.beginToken;
+ typeString = "";
+ while (token != identifierToken) {
+ typeString += " ${token.lexeme}";
+ token = token.next;
+ }
+ typeString = typeString.trim();
+ }
+
+ DirectParserASTContentFieldInitializerEnd initializer =
+ classFields.getFieldInitializer();
+ String initializerString = "";
+ if (initializer != null) {
+ Token token = initializer.assignment;
+ Token endToken = initializer.token;
+ while (token != endToken) {
+ initializerString += " ${token.lexeme}";
+ token = token.next;
+ }
+ initializerString = initializerString.trim();
+ }
+
+ Token beginToken = classFields.beginToken;
+ Token endToken = classFields.endToken;
+ assert(beginToken != null);
+ assert(endToken != null);
+
+ String frozenCheckCode =
+ """if (frozen) throw "Trying to modify frozen node!";""";
+
+ if (identifier == "parent" && entry.key == "TreeNode") {
+ // We update the parent for libraries for instance all the time (e.g.
+ // when we link).
+ frozenCheckCode = "";
+ } else if (identifier == "transformerFlags" && entry.key == "Member") {
+ // The verifier changes this for all libraries
+ // (and then change it back again).
+ frozenCheckCode = "";
+ } else if (identifier == "initializer" && entry.key == "Field") {
+ // The constant evaluator does some stuff here. Only allow that
+ // when it's basically a no-op though!
+ frozenCheckCode = """
+ if (frozen) {
+ if (_initializer is ConstantExpression && newValue is ConstantExpression) {
+ if ((_initializer as ConstantExpression).constant == newValue.constant) {
+ _initializer = newValue;
+ return;
+ }
+ }
+ throw "Trying to modify frozen node!";
+ }""";
+ }
+
+ if (!isFinal) {
+ replacements[beginToken] = new Replacement(beginToken, endToken, """
+$typeString _$identifier$initializerString;
+$typeString get $identifier => _$identifier;
+void set $identifier($typeString newValue) {
+ $frozenCheckCode
+ _$identifier = newValue;
+}""");
+ } else {
+ // Don't create setter for final field.
+ // TODO: Possibly wrap a list for instance of a non-writable one.
+ replacements[beginToken] = new Replacement(beginToken, endToken, """
+final $typeString _$identifier$initializerString;
+$typeString get $identifier => _$identifier;""");
+ }
+}
+
+void processConstructor(
+ DirectParserASTContentMemberEnd member,
+ Map<Token, Replacement> replacements,
+ Set<String> namedClassConstructors,
+ Set<String> namedFields) {
+ DirectParserASTContentClassConstructorEnd constructor =
+ member.getClassConstructor();
+ DirectParserASTContentFormalParametersEnd formalParameters =
+ constructor.getFormalParameters();
+ List<DirectParserASTContentFormalParameterEnd> parameters =
+ formalParameters.getFormalParameters();
+
+ for (DirectParserASTContentFormalParameterEnd parameter in parameters) {
+ Token token = parameter.getBegin().token;
+ if (token?.lexeme != "this") {
+ continue;
+ }
+ // Here `this.foo` can just be replace with `this._foo`.
+ Token afterDot = token.next.next;
+ replacements[afterDot] = new Replacement(afterDot, afterDot, "_$afterDot");
+ }
+
+ DirectParserASTContentOptionalFormalParametersEnd optionalFormalParameters =
+ formalParameters.getOptionalFormalParameters();
+ Set<String> addInitializers = {};
+ if (optionalFormalParameters != null) {
+ List<DirectParserASTContentFormalParameterEnd> parameters =
+ optionalFormalParameters.getFormalParameters();
+
+ for (DirectParserASTContentFormalParameterEnd parameter in parameters) {
+ Token token = parameter.getBegin().token;
+ if (token?.lexeme != "this") {
+ continue;
+ }
+ // Here `this.foo` can't just be replace with `this._foo` as it is
+ // (possibly) named and we can't use private stuff in named.
+ // Instead we replace it with `dynamic foo` here and add an
+ // initializer `this._foo = foo`.
+ Token afterDot = token.next.next;
+ addInitializers.add(afterDot.lexeme);
+ replacements[token] = new Replacement(token, token.next, "dynamic ");
+ }
+ }
+
+ DirectParserASTContentInitializersEnd initializers =
+ constructor.getInitializers();
+
+ // First patch up any existing initializers.
+ if (initializers != null) {
+ List<DirectParserASTContentInitializerEnd> actualInitializers =
+ initializers.getInitializers();
+ for (DirectParserASTContentInitializerEnd initializer
+ in actualInitializers) {
+ Token token = initializer.getBegin().token;
+ // This is only afterDot if there's a dot --- which (probably) is
+ // only there if there's a `this`.
+ Token afterDot = token.next.next;
+
+ // We need to check it's not a redirecting call!
+ // TODO(jensj): Handle redirects like this:
+ // class C {
+ // C();
+ // C.redirect() : this();
+ // }
+ if (token.lexeme == "this" &&
+ namedClassConstructors.contains(afterDot.lexeme)) {
+ // Redirect!
+ continue;
+ }
+
+ if (token.lexeme == "this") {
+ // Here `this.foo` can just be replace with `this._foo`.
+ assert(namedFields.contains(afterDot.lexeme));
+ replacements[afterDot] =
+ new Replacement(afterDot, afterDot, "_$afterDot");
+ } else if (token.lexeme == "super") {
+ // Don't try to patch this one.
+ } else if (token.lexeme == "assert") {
+ List<DirectParserASTContentIdentifierHandle> identifiers = initializer
+ .recursivelyFind<DirectParserASTContentIdentifierHandle>();
+ for (Token token in identifiers.map((e) => e.token)) {
+ if (namedFields.contains(token.lexeme)) {
+ replacements[token] = new Replacement(token, token, "_$token");
+ }
+ }
+ } else {
+ assert(namedFields.contains(token.lexeme),
+ "${token.lexeme} isn't a known field among ${namedFields}");
+ replacements[token] = new Replacement(token, token, "_$token");
+ }
+ }
+ }
+
+ // Then add any new ones.
+ if (addInitializers.isNotEmpty && initializers == null) {
+ // No initializers => Fake one by inserting `:` and all `_foo = foo`
+ // entries.
+ Token endToken = formalParameters.endToken;
+ String initializerString =
+ addInitializers.map((e) => "this._$e = $e").join(",\n");
+ replacements[endToken] =
+ new Replacement(endToken, endToken, ") : $initializerString");
+ } else if (addInitializers.isNotEmpty) {
+ // Add to existing initializer list. We add them as the first one(s)
+ // so we don't have to insert before the potential super call.
+ DirectParserASTContentInitializersBegin firstOne = initializers.getBegin();
+ Token colon = firstOne.token;
+ assert(colon.lexeme == ":");
+ String initializerString =
+ addInitializers.map((e) => "this._$e = $e").join(", ");
+ replacements[colon] =
+ new Replacement(colon, colon, ": $initializerString,");
+ }
+
+ // If there are anything in addInitializers we need to patch
+ // up the body too -- if we replace `{this.foo}` with `{dynamic foo}`
+ // and the body says `foo = 42;` before that would change the field,
+ // now it will change the parameter value. We must patch up all usages
+ // - even reads to work on things like
+ // class C {
+ // int field1;
+ // int field2;
+ // C(this.field1) : field2 = field1 + 1;
+ // }
+ if (addInitializers.isNotEmpty) {
+ DirectParserASTContentBlockFunctionBodyEnd blockFunctionBody =
+ constructor.getBlockFunctionBody();
+ if (blockFunctionBody != null) {
+ List<DirectParserASTContentIdentifierHandle> identifiers =
+ blockFunctionBody
+ .recursivelyFind<DirectParserASTContentIdentifierHandle>();
+ for (DirectParserASTContentIdentifierHandle identifier in identifiers) {
+ Token token = identifier.token;
+ IdentifierContext context = identifier.context;
+ if (namedFields.contains(token.lexeme) &&
+ addInitializers.contains(token.lexeme)) {
+ // For now naively assume that if it's a continuation it says
+ // `this.`
+ if (!context.isContinuation) {
+ replacements[token] = new Replacement(token, token, "_$token");
+ }
+ }
+ }
+ }
+ }
+}
+
+class Replacement {
+ final Token beginToken;
+ final Token endToken;
+ final String replacement;
+
+ Replacement(this.beginToken, this.endToken, this.replacement);
+}
+
+String getExtends(DirectParserASTContentTopLevelDeclarationEnd cls) {
+ DirectParserASTContentClassDeclarationEnd classDeclaration =
+ cls.getClassDeclaration();
+
+ DirectParserASTContentClassExtendsHandle classExtends =
+ classDeclaration.getClassExtends();
+ Token extendsKeyword = classExtends.extendsKeyword;
+ if (extendsKeyword == null) {
+ return null;
+ } else {
+ return extendsKeyword.next.toString();
+ }
+}
+
+void debugDumpNode(DirectParserASTContent node) {
+ node.children.forEach((element) {
+ print("${element.what} (${element.deprecatedArguments}) "
+ "(${element.children})");
+ });
+}
+
+void debugDumpNodeRecursively(DirectParserASTContent node,
+ {String indent = ""}) {
+ print("$indent${node.what} (${node.deprecatedArguments})");
+ if (node.children == null) return;
+ node.children.forEach((element) {
+ print("$indent${element.what} (${element.deprecatedArguments})");
+ if (element.children != null) {
+ element.children.forEach((element) {
+ debugDumpNodeRecursively(element, indent: " $indent");
+ });
+ }
+ });
+}
diff --git a/pkg/front_end/tool/parser_direct_ast/viewer.dart b/pkg/front_end/tool/parser_direct_ast/viewer.dart
index 8bcf65e..c516101 100644
--- a/pkg/front_end/tool/parser_direct_ast/viewer.dart
+++ b/pkg/front_end/tool/parser_direct_ast/viewer.dart
@@ -64,22 +64,20 @@
case DirectParserASTType.BEGIN:
header = "begin";
break;
- case DirectParserASTType.END:
- throw "Unexpected";
case DirectParserASTType.HANDLE:
header = "handle";
break;
- case DirectParserASTType.DONE:
+ case DirectParserASTType.END:
header = withEndHeader ? "end" : "";
break;
}
String extra = " ";
- if (element.content != null) {
- extra += element.content.first.arguments.toString();
+ if (element.children != null) {
+ extra += element.children.first.deprecatedArguments.toString();
}
return "${indent ? " " : ""}"
"${header}${element.what} "
- "${element.arguments.toString()}${extra}";
+ "${element.deprecatedArguments.toString()}${extra}";
}
@override
@@ -116,7 +114,7 @@
selected = selectedElement.selected;
} else {
shown = [new PrintedLine.parent(shown, selected)];
- List<DirectParserASTContent> children = selectedElement.ast.content;
+ List<DirectParserASTContent> children = selectedElement.ast.children;
if (children != null) {
for (int i = 0; i < children.length; i++) {
shown.add(new PrintedLine.ast(
diff --git a/pkg/vm/lib/transformations/protobuf_aware_treeshaker/transformer.dart b/pkg/vm/lib/transformations/protobuf_aware_treeshaker/transformer.dart
index 2a88c7c..e216685 100644
--- a/pkg/vm/lib/transformations/protobuf_aware_treeshaker/transformer.dart
+++ b/pkg/vm/lib/transformations/protobuf_aware_treeshaker/transformer.dart
@@ -50,6 +50,16 @@
component.metadata.clear();
}
+/// Called by the signature shaker to exclude the positional parameters of
+/// certain members whose first few parameters are depended upon by the
+/// protobuf-aware tree shaker.
+bool excludePositionalParametersFromSignatureShaking(Member member) {
+ return member.enclosingClass?.name == 'BuilderInfo' &&
+ member.enclosingLibrary.importUri ==
+ Uri.parse('package:protobuf/protobuf.dart') &&
+ _UnusedFieldMetadataPruner.fieldAddingMethods.contains(member.name.name);
+}
+
InfoCollector removeUnusedProtoReferences(
Component component, CoreTypes coreTypes, TransformationInfo info) {
final protobufUri = Uri.parse('package:protobuf/protobuf.dart');
diff --git a/pkg/vm/lib/transformations/type_flow/signature_shaking.dart b/pkg/vm/lib/transformations/type_flow/signature_shaking.dart
index 096acaf..8be7d86 100644
--- a/pkg/vm/lib/transformations/type_flow/signature_shaking.dart
+++ b/pkg/vm/lib/transformations/type_flow/signature_shaking.dart
@@ -10,6 +10,8 @@
import 'table_selector_assigner.dart';
import 'types.dart';
import 'utils.dart';
+import '../protobuf_aware_treeshaker/transformer.dart'
+ show excludePositionalParametersFromSignatureShaking;
import '../../metadata/procedure_attributes.dart';
/// Transform parameters from optional to required when they are always passed,
@@ -19,23 +21,32 @@
/// are grouped by table selector ID and thus can cover several implementations.
///
/// Definitions:
+/// - A parameter is checked if it requires a runtime check, either because it
+/// is covariant or it is non-nullable and sound null safety is not enabled.
+/// If sound null safety is not enabled, the analysis currently conservatively
+/// assumes that null assertions are enabled. If we add a flag for null
+/// assertions to gen_kernel, this flag can form part of the definition.
/// - A parameter is used if it is mentioned in the body (or, for constructors,
-/// an initializer) of any implementation.
+/// an initializer) of any implementation, or it is checked. An occurrence as
+/// an argument to a call (a use dependency) is only considered a use if the
+/// corresponding target parameter is used.
/// - A parameter can be eliminated if either:
-/// 1. it is not used; or
-/// 2. it is never passed and is not written to in any implementation.
+/// 1. it is not used,
+/// 2. it is never passed and is not written to in any implementation, or
+/// 3. it is a constant (though not necessarily the same constant) in every
+/// implementation and is neither written to nor checked.
/// - A function is eligible if it is not external and is guaranteed to not be
/// called with an unknown call signature.
///
/// All eligible signatures are transformed such that they contain, in order:
-/// 1. All used positional parameters that are always passed, as required
-/// positional parameters.
-/// 2. All used named parameters that are always passed, as required positional
-/// parameters, alphabetically by name.
-/// 3. All used positional parameters that are not always passed and can't be
+/// 1. All positional parameters that are always passed and can't be
+/// eliminated, as required positional parameters.
+/// 2. All named parameters that are always passed and can't be eliminated,
+/// as required positional parameters, alphabetically by name.
+/// 3. All positional parameters that are not always passed and can't be
/// eliminated, as positional parameters, each one required iff it was
/// originally required.
-/// 4. All used named parameters that are not always passed and can't be
+/// 4. All named parameters that are not always passed and can't be
/// eliminated, as named parameters in alphabetical order.
class SignatureShaker {
final TypeFlowAnalysis typeFlowAnalysis;
@@ -64,8 +75,48 @@
void transformComponent(Component component) {
_Collect(this).visitComponent(component);
+ _resolveUseDependencies();
_Transform(this).visitComponent(component);
}
+
+ void _resolveUseDependencies() {
+ List<_ParameterInfo> worklist = [];
+ for (_ProcedureInfo info in _memberInfo.values) {
+ _addUseDependenciesForProcedure(info, worklist);
+ }
+ for (_ProcedureInfo info in _selectorInfo.values) {
+ _addUseDependenciesForProcedure(info, worklist);
+ }
+ while (worklist.isNotEmpty) {
+ _ParameterInfo param = worklist.removeLast();
+ for (_ParameterInfo dependencyParam in param.useDependencies) {
+ if (!dependencyParam.isRead) {
+ dependencyParam.isRead = true;
+ if (dependencyParam.useDependencies != null) {
+ worklist.add(dependencyParam);
+ }
+ }
+ }
+ }
+ }
+
+ void _addUseDependenciesForProcedure(
+ _ProcedureInfo info, List<_ParameterInfo> worklist) {
+ for (_ParameterInfo param in info.positional) {
+ _addUseDependenciesForParameter(param, worklist);
+ }
+ for (_ParameterInfo param in info.named.values) {
+ _addUseDependenciesForParameter(param, worklist);
+ }
+ }
+
+ void _addUseDependenciesForParameter(
+ _ParameterInfo param, List<_ParameterInfo> worklist) {
+ if ((param.isUsed || !param.info.eligible) &&
+ param.useDependencies != null) {
+ worklist.add(param);
+ }
+ }
}
class _ProcedureInfo {
@@ -74,6 +125,11 @@
int callCount = 0;
bool eligible = true;
+ /// Whether positional parameters can be eliminated from this member. Some
+ /// protobuf methods require these parameters to be preserved for the
+ /// protobuf-aware tree shaker to function.
+ bool canEliminatePositional = true;
+
_ParameterInfo ensurePositional(int i) {
if (positional.length <= i) {
assert(positional.length == i);
@@ -103,32 +159,49 @@
int passCount = 0;
bool isRead = false;
bool isWritten = false;
+ bool isChecked = false;
+ bool isConstant = true;
+
+ /// List of parameter variables which were passed as arguments via this
+ /// parameter. When this parameter is considered used, all [useDependencies]
+ /// parameters should be transitively marked as read.
+ List<_ParameterInfo> useDependencies = null;
_ParameterInfo(this.info, this.index);
bool get isNamed => index == null;
- bool get isUsed => isRead || isWritten;
+ bool get isUsed => isRead || isWritten || isChecked;
bool get isAlwaysPassed => passCount == info.callCount;
bool get isNeverPassed => passCount == 0;
- bool get canBeEliminated => !isUsed || isNeverPassed && !isWritten;
+ bool get canBeEliminated =>
+ (!isUsed || (isNeverPassed || isConstant && !isChecked) && !isWritten) &&
+ (isNamed || info.canEliminatePositional);
- void observeImplicitChecks(
+ void observeParameter(
Member member, VariableDeclaration param, SignatureShaker shaker) {
- if (param.isCovariant || param.isGenericCovariantImpl) {
- // Covariant parameters have implicit type checks, which count as reads.
- isRead = true;
- } else if (param.type.nullability == Nullability.nonNullable) {
- // When run in weak mode with null assertions enabled, parameters with
- // non-nullable types have implicit null checks, which count as reads.
- Type type = shaker.typeFlowAnalysis.argumentType(member, param);
- if (type == null || type is NullableType) {
- // TFA can't guarantee that the value isn't null. Preserve check.
- isRead = true;
- }
+ final Type type = shaker.typeFlowAnalysis.argumentType(member, param);
+
+ // A parameter is considered constant if the TFA has inferred it to have a
+ // constant value in every implementation. The constant value inferred does
+ // not have to be the same across implementations, as it is specialized in
+ // each implementation individually.
+ if (!(type is ConcreteType && type.constant != null ||
+ type is NullableType && type.baseType is EmptyType)) {
+ isConstant = false;
+ }
+
+ // Covariant parameters have implicit type checks, which count as reads.
+ // When run in weak mode with null assertions enabled, parameters with
+ // non-nullable types have implicit null checks, which count as reads.
+ if ((param.isCovariant || param.isGenericCovariantImpl) ||
+ (!shaker.typeFlowAnalysis.target.flags.enableNullSafety &&
+ param.type.nullability == Nullability.nonNullable &&
+ (type == null || type is NullableType))) {
+ isChecked = true;
}
}
}
@@ -136,8 +209,14 @@
class _Collect extends RecursiveVisitor<void> {
final SignatureShaker shaker;
+ /// Parameters of the current function.
final Map<VariableDeclaration, _ParameterInfo> localParameters = {};
+ /// Set of [VariableGet] nodes corresponding to parameters in the current
+ /// function which are passed as arguments to eligible calls. They are tracked
+ /// via [_ParameterInfo.useDependencies] and not marked as read immediately.
+ final Set<VariableGet> useDependencies = {};
+
_Collect(this.shaker);
void enterFunction(Member member) {
@@ -145,15 +224,16 @@
if (info == null) return;
localParameters.clear();
+ useDependencies.clear();
final FunctionNode fun = member.function;
for (int i = 0; i < fun.positionalParameters.length; i++) {
final VariableDeclaration param = fun.positionalParameters[i];
localParameters[param] = info.ensurePositional(i)
- ..observeImplicitChecks(member, param, shaker);
+ ..observeParameter(member, param, shaker);
}
for (VariableDeclaration param in fun.namedParameters) {
localParameters[param] = info.ensureNamed(param.name)
- ..observeImplicitChecks(member, param, shaker);
+ ..observeParameter(member, param, shaker);
}
if (shaker.typeFlowAnalysis.isCalledDynamically(member) ||
@@ -164,6 +244,10 @@
getExternalName(member) != null) {
info.eligible = false;
}
+
+ if (excludePositionalParametersFromSignatureShaking(member)) {
+ info.canEliminatePositional = false;
+ }
}
@override
@@ -180,7 +264,10 @@
@override
void visitVariableGet(VariableGet node) {
- localParameters[node.variable]?.isRead = true;
+ // Variable reads marked as use dependencies are not considered reads
+ // immediately. Their status as a read or not will be computed after all use
+ // dependencies have been collected.
+ localParameters[node.variable]?.isRead |= !useDependencies.contains(node);
super.visitVariableGet(node);
}
@@ -190,15 +277,32 @@
super.visitVariableSet(node);
}
+ void addUseDependency(Expression arg, _ParameterInfo param) {
+ if (arg is VariableGet) {
+ _ParameterInfo localParam = localParameters[arg.variable];
+ if (localParam != null && !localParam.isUsed) {
+ // This is a parameter passed as an argument. Mark it as a use
+ // dependency.
+ param.useDependencies ??= [];
+ param.useDependencies.add(localParam);
+ useDependencies.add(arg);
+ }
+ }
+ }
+
void collectCall(Member member, Arguments args) {
final _ProcedureInfo info = shaker._infoForMember(member);
if (info == null) return;
for (int i = 0; i < args.positional.length; i++) {
- info.ensurePositional(i).passCount++;
+ _ParameterInfo param = info.ensurePositional(i);
+ param.passCount++;
+ addUseDependency(args.positional[i], param);
}
for (NamedExpression named in args.named) {
- info.ensureNamed(named.name).passCount++;
+ _ParameterInfo param = info.ensureNamed(named.name);
+ param.passCount++;
+ addUseDependency(named.value, param);
}
info.callCount++;
}
@@ -244,15 +348,36 @@
final SignatureShaker shaker;
StaticTypeContext typeContext;
- final Set<VariableDeclaration> eliminatedParams = {};
+ final Map<VariableDeclaration, Constant> eliminatedParams = {};
+ final Set<VariableDeclaration> unusedParams = {};
final List<LocalInitializer> addedInitializers = [];
_Transform(this.shaker);
+ void eliminateUsedParameter(
+ Member member, _ParameterInfo param, VariableDeclaration variable) {
+ Constant value;
+ if (param.isConstant) {
+ Type type = shaker.typeFlowAnalysis.argumentType(member, variable);
+ if (type is ConcreteType) {
+ assert(type.constant != null);
+ value = type.constant;
+ } else {
+ assert(type is NullableType && type.baseType is EmptyType);
+ value = NullConstant();
+ }
+ } else {
+ value = (variable.initializer as ConstantExpression)?.constant ??
+ NullConstant();
+ }
+ eliminatedParams[variable] = value;
+ }
+
void transformMemberSignature(Member member) {
typeContext =
StaticTypeContext(member, shaker.typeFlowAnalysis.environment);
eliminatedParams.clear();
+ unusedParams.clear();
final _ProcedureInfo info = shaker._infoForMember(member);
if (info == null || !info.eligible || info.callCount == 0) return;
@@ -263,42 +388,61 @@
final List<VariableDeclaration> positional = [];
final List<VariableDeclaration> named = [];
- // 1. All used positional parameters that are always passed, as required
- // positional parameters.
+ // 1. All positional parameters that are always passed and can't be
+ // eliminated, as required positional parameters.
+ int firstNotAlwaysPassed = function.positionalParameters.length;
for (int i = 0; i < function.positionalParameters.length; i++) {
final _ParameterInfo param = info.positional[i];
- if (!param.isAlwaysPassed) break;
+ if (!param.isAlwaysPassed) {
+ firstNotAlwaysPassed = i;
+ break;
+ }
+ final VariableDeclaration variable = function.positionalParameters[i];
if (param.isUsed) {
- final VariableDeclaration variable = function.positionalParameters[i];
- positional.add(variable);
- variable.initializer = null;
+ if (param.canBeEliminated) {
+ eliminateUsedParameter(member, param, variable);
+ } else {
+ positional.add(variable);
+ variable.initializer = null;
+ }
+ } else {
+ unusedParams.add(variable);
}
}
- // 2. All used named parameters that are always passed, as required
- // positional parameters, alphabetically by name.
+ // 2. All named parameters that are always passed and can't be eliminated,
+ // as required positional parameters, alphabetically by name.
final List<VariableDeclaration> sortedNamed = function.namedParameters
.toList()
..sort((var1, var2) => var1.name.compareTo(var2.name));
for (VariableDeclaration variable in sortedNamed) {
final _ParameterInfo param = info.named[variable.name];
- if (param.isUsed && param.isAlwaysPassed) {
- variable.initializer = null;
- variable.isRequired = false;
- positional.add(variable);
+ if (param.isAlwaysPassed) {
+ if (param.isUsed) {
+ if (param.canBeEliminated) {
+ eliminateUsedParameter(member, param, variable);
+ } else {
+ variable.initializer = null;
+ variable.isRequired = false;
+ positional.add(variable);
+ }
+ } else {
+ unusedParams.add(variable);
+ }
}
}
int requiredParameterCount = positional.length;
- // 3. All used positional parameters that are not always passed and can't be
+ // 3. All positional parameters that are not always passed and can't be
// eliminated, as positional parameters, each one required iff it was
// originally required.
- for (int i = 0; i < function.positionalParameters.length; i++) {
+ for (int i = firstNotAlwaysPassed;
+ i < function.positionalParameters.length;
+ i++) {
final _ParameterInfo param = info.positional[i];
+ assert(!param.isAlwaysPassed);
+ final VariableDeclaration variable = function.positionalParameters[i];
if (param.isUsed) {
- final VariableDeclaration variable = function.positionalParameters[i];
if (param.canBeEliminated) {
- assert(variable.initializer == null ||
- variable.initializer is ConstantExpression);
- eliminatedParams.add(variable);
+ eliminateUsedParameter(member, param, variable);
} else if (!param.isAlwaysPassed) {
positional.add(variable);
if (i < function.requiredParameterCount) {
@@ -309,19 +453,23 @@
requiredParameterCount++;
}
}
+ } else {
+ unusedParams.add(variable);
}
}
- // 4. All used named parameters that are not always passed and can't be
+ // 4. All named parameters that are not always passed and can't be
// eliminated, as named parameters in alphabetical order.
for (VariableDeclaration variable in sortedNamed) {
final _ParameterInfo param = info.named[variable.name];
- if (param.isUsed) {
- if (param.canBeEliminated) {
- assert(variable.initializer == null ||
- variable.initializer is ConstantExpression);
- eliminatedParams.add(variable);
- } else if (!param.isAlwaysPassed) {
- named.add(variable);
+ if (!param.isAlwaysPassed) {
+ if (param.isUsed) {
+ if (param.canBeEliminated) {
+ eliminateUsedParameter(member, param, variable);
+ } else {
+ named.add(variable);
+ }
+ } else {
+ unusedParams.add(variable);
}
}
}
@@ -336,10 +484,9 @@
@override
void visitVariableGet(VariableGet node) {
- if (eliminatedParams.contains(node.variable)) {
- final ConstantExpression initializer = node.variable.initializer;
- node.replaceWith(
- ConstantExpression(initializer?.constant ?? NullConstant()));
+ Constant constantValue = eliminatedParams[node.variable];
+ if (constantValue != null) {
+ node.replaceWith(ConstantExpression(constantValue));
}
}
@@ -383,7 +530,7 @@
bool hoistingNeeded = false;
forEachArgumentRev(args, info, (Expression arg, _ParameterInfo param) {
assert(!param.isNeverPassed);
- if (!param.isUsed || param.isNamed && param.isAlwaysPassed) {
+ if (param.canBeEliminated || param.isNamed && param.isAlwaysPassed) {
transformNeeded = true;
if (mayHaveSideEffects(arg)) {
hoistingNeeded = true;
@@ -393,12 +540,16 @@
if (!transformNeeded) return;
+ bool isUnusedParam(Expression exp) {
+ return exp is VariableGet && unusedParams.contains(exp.variable);
+ }
+
Map<Expression, VariableDeclaration> hoisted = {};
if (hoistingNeeded) {
if (call is Initializer) {
final Constructor constructor = call.parent;
forEachArgumentRev(args, info, (Expression arg, _ParameterInfo param) {
- if (mayHaveOrSeeSideEffects(arg)) {
+ if (mayHaveOrSeeSideEffects(arg) && !isUnusedParam(arg)) {
VariableDeclaration argVar = VariableDeclaration(null,
initializer: arg,
type: arg.getStaticType(typeContext),
@@ -412,7 +563,7 @@
final TreeNode parent = call.parent;
Expression current = call;
forEachArgumentRev(args, info, (Expression arg, _ParameterInfo param) {
- if (mayHaveOrSeeSideEffects(arg)) {
+ if (mayHaveOrSeeSideEffects(arg) && !isUnusedParam(arg)) {
VariableDeclaration argVar = VariableDeclaration(null,
initializer: arg,
type: arg.getStaticType(typeContext),
@@ -422,6 +573,7 @@
}
});
if (receiver != null && mayHaveOrSeeSideEffects(receiver)) {
+ assert(!isUnusedParam(receiver));
assert(receiver.parent == call);
final VariableDeclaration receiverVar = VariableDeclaration(null,
initializer: receiver,
@@ -443,41 +595,41 @@
final List<Expression> positional = [];
final List<NamedExpression> named = [];
- // 1. All used positional parameters that are always passed, as required
- // positional parameters.
+ // 1. All positional parameters that are always passed and can't be
+ // eliminated, as required positional parameters.
for (int i = 0; i < args.positional.length; i++) {
final _ParameterInfo param = info.positional[i];
final Expression arg = args.positional[i];
- if (param.isUsed && param.isAlwaysPassed) {
+ if (param.isAlwaysPassed && !param.canBeEliminated) {
positional.add(getMaybeHoistedArg(arg));
}
}
- // 2. All used named parameters that are always passed, as required
- // positional parameters, alphabetically by name.
+ // 2. All named parameters that are always passed and can't be eliminated,
+ // as required positional parameters, alphabetically by name.
final List<NamedExpression> sortedNamed = args.named.toList()
..sort((var1, var2) => var1.name.compareTo(var2.name));
for (NamedExpression arg in sortedNamed) {
final _ParameterInfo param = info.named[arg.name];
- if (param.isUsed && param.isAlwaysPassed) {
+ if (param.isAlwaysPassed && !param.canBeEliminated) {
positional.add(getMaybeHoistedArg(arg.value));
}
}
- // 3. All used positional parameters that are not always passed and can't be
+ // 3. All positional parameters that are not always passed and can't be
// eliminated, as positional parameters, each one required iff it was
// originally required.
for (int i = 0; i < args.positional.length; i++) {
final _ParameterInfo param = info.positional[i];
final Expression arg = args.positional[i];
- if (param.isUsed && !param.isAlwaysPassed) {
+ if (!param.isAlwaysPassed && !param.canBeEliminated) {
positional.add(getMaybeHoistedArg(arg));
}
}
- // 4. All used named parameters that are not always passed and can't be
+ // 4. All named parameters that are not always passed and can't be
// eliminated, as named parameters in alphabetical order.
// (Arguments are kept in original order.)
for (NamedExpression arg in args.named) {
final _ParameterInfo param = info.named[arg.name];
- if (param.isUsed && !param.isAlwaysPassed) {
+ if (!param.isAlwaysPassed && !param.canBeEliminated) {
arg.value = getMaybeHoistedArg(arg.value)..parent = arg;
named.add(arg);
}
diff --git a/pkg/vm/test/transformations/protobuf_aware_treeshaker/treeshaker_test.dart b/pkg/vm/test/transformations/protobuf_aware_treeshaker/treeshaker_test.dart
index 707b1fd..4a29089 100644
--- a/pkg/vm/test/transformations/protobuf_aware_treeshaker/treeshaker_test.dart
+++ b/pkg/vm/test/transformations/protobuf_aware_treeshaker/treeshaker_test.dart
@@ -12,6 +12,8 @@
import 'package:path/path.dart' as path;
import 'package:test/test.dart';
+import 'package:vm/kernel_front_end.dart'
+ show runGlobalTransformations, ErrorDetector;
import 'package:vm/transformations/protobuf_aware_treeshaker/transformer.dart'
as treeshaker;
@@ -20,7 +22,12 @@
final String pkgVmDir = Platform.script.resolve('../../..').toFilePath();
runTestCase(Uri source) async {
- final target = new TestingVmTarget(new TargetFlags());
+ await shakeAndRun(source);
+ await compileAOT(source);
+}
+
+Future<void> shakeAndRun(Uri source) async {
+ final target = TestingVmTarget(TargetFlags());
Component component =
await compileTestCaseToKernelProgram(source, target: target);
@@ -42,8 +49,7 @@
}
final systemTempDir = Directory.systemTemp;
- final file =
- new File('${systemTempDir.path}/${source.pathSegments.last}.dill');
+ final file = File('${systemTempDir.path}/${source.pathSegments.last}.dill');
try {
final sink = file.openWrite();
final printer = BinaryPrinter(sink, includeSources: false);
@@ -61,6 +67,30 @@
}
}
+Future<void> compileAOT(Uri source) async {
+ final target = TestingVmTarget(TargetFlags());
+ Component component =
+ await compileTestCaseToKernelProgram(source, target: target);
+
+ // Imitate the global transformations as run by the protobuf-aware tree shaker
+ // in AOT mode.
+ // Copied verbatim from pkg/vm/bin/protobuf_aware_treeshaker.dart.
+ const bool useGlobalTypeFlowAnalysis = true;
+ const bool enableAsserts = false;
+ const bool useProtobufAwareTreeShaker = true;
+ const bool useProtobufAwareTreeShakerV2 = false;
+ final nopErrorDetector = ErrorDetector();
+ runGlobalTransformations(
+ target,
+ component,
+ useGlobalTypeFlowAnalysis,
+ enableAsserts,
+ useProtobufAwareTreeShaker,
+ useProtobufAwareTreeShakerV2,
+ nopErrorDetector,
+ );
+}
+
main() async {
final testCases = Directory(path.join(
pkgVmDir,
diff --git a/pkg/vm/testcases/transformations/type_flow/transformer/bench_is_prime.dart.expect b/pkg/vm/testcases/transformations/type_flow/transformer/bench_is_prime.dart.expect
index d9f0804..173e18b 100644
--- a/pkg/vm/testcases/transformations/type_flow/transformer/bench_is_prime.dart.expect
+++ b/pkg/vm/testcases/transformations/type_flow/transformer/bench_is_prime.dart.expect
@@ -12,19 +12,19 @@
}
return true;
}
-[@vm.unboxing-info.metadata=(i)->b]static method nThPrimeNumber([@vm.inferred-type.metadata=dart.core::_Smi (value: 50000)] core::int* n) → core::int* {
+static method nThPrimeNumber() → core::int* {
core::int* counter = 0;
for (core::int* i = 1; ; i = [@vm.direct-call.metadata=dart.core::_IntegerImplementation.+??] [@vm.inferred-type.metadata=int (skip check)] i.{core::num::+}(1)) {
if([@vm.inferred-type.metadata=dart.core::bool] self::isPrime(i))
counter = [@vm.direct-call.metadata=dart.core::_IntegerImplementation.+??] [@vm.inferred-type.metadata=int (skip check)] counter.{core::num::+}(1);
- if([@vm.inferred-type.metadata=dart.core::bool] counter.{core::num::==}(n)) {
+ if([@vm.inferred-type.metadata=dart.core::bool] counter.{core::num::==}(#C1)) {
return i;
}
}
}
static method run() → void {
core::int* e = 611953;
- core::int* p = [@vm.inferred-type.metadata=int?] self::nThPrimeNumber(50000);
+ core::int* p = [@vm.inferred-type.metadata=int?] self::nThPrimeNumber();
if(![@vm.inferred-type.metadata=dart.core::bool] p.{core::num::==}(e)) {
throw core::Exception::•("Unexpected result: ${p} != ${e}");
}
diff --git a/pkg/vm/testcases/transformations/type_flow/transformer/bench_vector.dart.expect b/pkg/vm/testcases/transformations/type_flow/transformer/bench_vector.dart.expect
index f30eaeb..71bb393 100644
--- a/pkg/vm/testcases/transformations/type_flow/transformer/bench_vector.dart.expect
+++ b/pkg/vm/testcases/transformations/type_flow/transformer/bench_vector.dart.expect
@@ -9,8 +9,8 @@
[@vm.inferred-type.metadata=dart.core::_Smi (value: 0)] [@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:1] [@vm.unboxing-info.metadata=()->i] final field core::int* _offset;
[@vm.inferred-type.metadata=dart.core::_Smi (value: 10)] [@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:2] [@vm.unboxing-info.metadata=()->i] final field core::int* _length;
[@vm.inferred-type.metadata=dart.typed_data::_Float64List] [@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:3] final field core::List<core::double*>* _elements;
-[@vm.unboxing-info.metadata=(i)->b] constructor •([@vm.inferred-type.metadata=dart.core::_Smi (value: 10)] core::int* size) → self::_Vector*
- : self::_Vector::_offset = 0, self::_Vector::_length = size, self::_Vector::_elements = [@vm.inferred-type.metadata=dart.typed_data::_Float64List] typ::Float64List::•(size), super core::Object::•()
+ constructor •() → self::_Vector*
+ : self::_Vector::_offset = 0, self::_Vector::_length = #C1, self::_Vector::_elements = [@vm.inferred-type.metadata=dart.typed_data::_Float64List] typ::Float64List::•(#C1), super core::Object::•()
;
[@vm.procedure-attributes.metadata=getterCalledDynamically:false,hasTearOffUses:false,methodOrSetterSelectorId:4] [@vm.unboxing-info.metadata=(b)->d] operator []([@vm.inferred-type.metadata=!] core::int* i) → core::double*
return [@vm.direct-call.metadata=dart.typed_data::_Float64List.[]] [@vm.inferred-type.metadata=dart.core::_Double (skip check)] [@vm.direct-call.metadata=#lib::_Vector._elements] [@vm.inferred-type.metadata=dart.typed_data::_Float64List] this.{self::_Vector::_elements}.{core::List::[]}([@vm.direct-call.metadata=dart.core::_IntegerImplementation.+] [@vm.inferred-type.metadata=int (skip check)] i.{core::num::+}([@vm.direct-call.metadata=#lib::_Vector._offset] [@vm.inferred-type.metadata=dart.core::_Smi (value: 0)] this.{self::_Vector::_offset}));
@@ -24,7 +24,7 @@
return result;
}
}
-[@vm.inferred-type.metadata=#lib::_Vector?]static field self::_Vector* v = new self::_Vector::•(10);
+[@vm.inferred-type.metadata=#lib::_Vector?]static field self::_Vector* v = new self::_Vector::•();
[@vm.inferred-type.metadata=dart.core::_Double?]static field core::double* x = 0.0;
static method main(core::List<core::String*>* args) → dynamic {
core::Stopwatch* timer = let final core::Stopwatch* #t3 = new core::Stopwatch::•() in block {
diff --git a/pkg/vm/testcases/transformations/type_flow/transformer/const_prop.dart.expect b/pkg/vm/testcases/transformations/type_flow/transformer/const_prop.dart.expect
index 8d122c1..29abf49 100644
--- a/pkg/vm/testcases/transformations/type_flow/transformer/const_prop.dart.expect
+++ b/pkg/vm/testcases/transformations/type_flow/transformer/const_prop.dart.expect
@@ -17,44 +17,44 @@
[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:6,getterSelectorId:7] method toString() → core::String*
return [@vm.direct-call.metadata=#lib::B._name] [@vm.inferred-type.metadata=dart.core::_OneByteString (value: "B.b2")] this.{self::B::_name};
}
-[@vm.unboxing-info.metadata=(i)->b]static method test0([@vm.inferred-type.metadata=dart.core::_Smi (value: 40)] core::int* arg) → void {
- core::print(arg);
-}
-static method test1() → void {
+static method test0() → void {
core::print(#C1);
}
-static method test2() → void {
+static method test1() → void {
core::print(#C2);
}
+static method test2() → void {
+ core::print(#C3);
+}
[@vm.unboxing-info.metadata=()->d]static get getD() → dynamic
return 100.0;
-[@vm.unboxing-info.metadata=(d)->b]static method testDouble([@vm.inferred-type.metadata=dart.core::_Double (value: 3.14)] core::double* arg) → void {
- core::print(arg);
+static method testDouble() → void {
+ core::print(#C4);
core::print([@vm.inferred-type.metadata=dart.core::_Double (value: 100.0)] self::getD);
}
-static method testStrings([@vm.inferred-type.metadata=#lib::A] self::A* a0, [@vm.inferred-type.metadata=dart.core::_OneByteString (value: "bazz")] core::String* a1) → void {
+static method testStrings([@vm.inferred-type.metadata=#lib::A] self::A* a0) → void {
core::print([@vm.direct-call.metadata=#lib::A.foo] [@vm.inferred-type.metadata=dart.core::_OneByteString (value: "foo")] a0.{self::A::foo});
core::print([@vm.direct-call.metadata=#lib::A.getBar] [@vm.inferred-type.metadata=dart.core::_OneByteString (skip check) (value: "bar")] a0.{self::A::getBar}());
- core::print(a1);
+ core::print(#C5);
}
-static method testPassEnum([@vm.inferred-type.metadata=#lib::B (value: const #lib::B{#lib::B.index: 1, #lib::B._name: "B.b2"})] self::B* arg) → void {
- self::testPassEnum2(arg);
+static method testPassEnum() → void {
+ self::testPassEnum2();
}
-static method testPassEnum2([@vm.inferred-type.metadata=#lib::B (value: const #lib::B{#lib::B.index: 1, #lib::B._name: "B.b2"})] self::B* arg) → void {
- core::print(arg);
+static method testPassEnum2() → void {
+ core::print(#C8);
}
static method getList() → dynamic
- return #C6;
-static method testList([@vm.inferred-type.metadata=dart.core::_ImmutableList (value: const <dart.core::int*>[1, 2, 3])] dynamic arg1) → void {
- core::print(arg1);
- core::print(#C9);
+ return #C11;
+static method testList() → void {
+ core::print(#C11);
+ core::print(#C14);
}
static method main() → dynamic {
- self::test0(40);
+ self::test0();
self::test1();
self::test2();
- self::testDouble(3.14);
- self::testStrings(new self::A::•(), "bazz");
- self::testPassEnum(#C11);
- self::testList([@vm.inferred-type.metadata=dart.core::_ImmutableList (value: const <dart.core::int*>[1, 2, 3])] self::getList());
+ self::testDouble();
+ self::testStrings(new self::A::•());
+ self::testPassEnum();
+ let final dynamic #t1 = [@vm.inferred-type.metadata=dart.core::_ImmutableList (value: const <dart.core::int*>[1, 2, 3])] self::getList() in self::testList();
}
diff --git a/pkg/vm/testcases/transformations/type_flow/transformer/devirt.dart.expect b/pkg/vm/testcases/transformations/type_flow/transformer/devirt.dart.expect
index 79e29be..cb18067 100644
--- a/pkg/vm/testcases/transformations/type_flow/transformer/devirt.dart.expect
+++ b/pkg/vm/testcases/transformations/type_flow/transformer/devirt.dart.expect
@@ -48,8 +48,8 @@
static method callerA4([@vm.inferred-type.metadata=#lib::D?] self::A* aa) → void {
[@vm.direct-call.metadata=#lib::C.foo??] [@vm.inferred-type.metadata=!? (skip check)] aa.{self::A::foo}();
}
-static method callerE1([@vm.inferred-type.metadata=dart.core::_OneByteString (value: "abc")] dynamic x) → void {
- [@vm.direct-call.metadata=dart.core::_StringBase.toString] [@vm.inferred-type.metadata=!? (skip check) (receiver not int)] x.{core::Object::toString}();
+static method callerE1() → void {
+ [@vm.direct-call.metadata=dart.core::_StringBase.toString] [@vm.inferred-type.metadata=!? (skip check) (receiver not int)](#C1).{core::Object::toString}();
}
static method callerE2([@vm.inferred-type.metadata=#lib::E?] dynamic x) → void {
[@vm.inferred-type.metadata=!? (receiver not int)] x.{core::Object::toString}();
@@ -61,6 +61,6 @@
let final self::C* #t1 = new self::C::•() in self::callerA3(#t1);
self::callerA4([@vm.inferred-type.metadata=#lib::D?] self::dd);
self::dd = new self::D::•();
- self::callerE1("abc");
+ self::callerE1();
self::callerE2([@vm.inferred-type.metadata=#lib::E?] self::ee);
}
diff --git a/pkg/vm/testcases/transformations/type_flow/transformer/invalidation_cycle.dart.expect b/pkg/vm/testcases/transformations/type_flow/transformer/invalidation_cycle.dart.expect
index 387080e..59e2b69 100644
--- a/pkg/vm/testcases/transformations/type_flow/transformer/invalidation_cycle.dart.expect
+++ b/pkg/vm/testcases/transformations/type_flow/transformer/invalidation_cycle.dart.expect
@@ -21,14 +21,14 @@
synthetic constructor •() → self::Stream*
: super core::Object::•()
;
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:1,getterSelectorId:2] abstract method foobar((dynamic) →* void onData, {core::Function* onError = #C1}) → self::StreamSubscription*;
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:1,getterSelectorId:2] abstract method foobar() → self::StreamSubscription*;
[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:3] abstract member-signature operator ==(dynamic other) → core::bool*; -> core::Object::==
}
abstract class _StreamImpl extends self::Stream {
synthetic constructor •() → self::_StreamImpl*
: super self::Stream::•()
;
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:1,getterSelectorId:2] method foobar([@vm.inferred-type.metadata=dart.core::Null? (value: null)] (dynamic) →* void onData, {[@vm.inferred-type.metadata=dart.core::Null? (value: null)] core::Function* onError = #C1}) → self::StreamSubscription* {
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:1,getterSelectorId:2] method foobar() → self::StreamSubscription* {
return [@vm.inferred-type.metadata=! (skip check)] this.{self::_StreamImpl::_createSubscription}();
}
[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasNonThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:4,getterSelectorId:5] method _createSubscription() → self::StreamSubscription* {
@@ -53,22 +53,22 @@
constructor •([@vm.inferred-type.metadata=!] self::Stream* stream) → self::StreamView*
: self::StreamView::_stream = stream, super self::Stream::•()
;
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasTearOffUses:false,methodOrSetterSelectorId:1,getterSelectorId:2] method foobar([@vm.inferred-type.metadata=dart.core::Null? (value: null)] (dynamic) →* void onData, {[@vm.inferred-type.metadata=dart.core::Null? (value: null)] core::Function* onError = #C1}) → self::StreamSubscription* {
- return [@vm.direct-call.metadata=#lib::StreamView._stream] [@vm.inferred-type.metadata=!] this.{self::StreamView::_stream}.{self::Stream::foobar}(onData, onError: onError);
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasTearOffUses:false,methodOrSetterSelectorId:1,getterSelectorId:2] method foobar() → self::StreamSubscription* {
+ return [@vm.direct-call.metadata=#lib::StreamView._stream] [@vm.inferred-type.metadata=!] this.{self::StreamView::_stream}.{self::Stream::foobar}();
}
}
class ByteStream extends self::StreamView {
constructor •([@vm.inferred-type.metadata=!] self::Stream* stream) → self::ByteStream*
: super self::StreamView::•(stream)
;
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:7,getterSelectorId:8] method super_foobar1([@vm.inferred-type.metadata=dart.core::Null? (value: null)] (dynamic) →* void onData) → dynamic {
- super.{self::StreamView::foobar}(onData);
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:7,getterSelectorId:8] method super_foobar1() → dynamic {
+ super.{self::StreamView::foobar}();
}
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:9,getterSelectorId:10] method super_foobar2([@vm.inferred-type.metadata=dart.core::Null? (value: null)] (dynamic) →* void onData) → dynamic {
- super.{self::StreamView::foobar}(onData);
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:9,getterSelectorId:10] method super_foobar2() → dynamic {
+ super.{self::StreamView::foobar}();
}
[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:11,getterSelectorId:12] method super_foobar3() → dynamic {
- super.{self::StreamView::foobar}(#C1, onError: #C1);
+ super.{self::StreamView::foobar}();
}
[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:13] get super_stream() → self::Stream*
return [@vm.inferred-type.metadata=!] super.{self::StreamView::_stream};
@@ -83,26 +83,26 @@
}
static method round1() → void {
self::ByteStream* x = new self::ByteStream::•(new self::ByteStream::•(new self::_GeneratedStreamImpl::•()));
- [@vm.direct-call.metadata=#lib::ByteStream.super_foobar1] [@vm.inferred-type.metadata=!? (skip check)] x.{self::ByteStream::super_foobar1}(#C1);
+ [@vm.direct-call.metadata=#lib::ByteStream.super_foobar1] [@vm.inferred-type.metadata=!? (skip check)] x.{self::ByteStream::super_foobar1}();
}
static method round2() → void {
new self::_ControllerStream::•();
self::Stream* x = new self::_GeneratedStreamImpl::•();
x = new self::ByteStream::•(x);
- [@vm.direct-call.metadata=#lib::StreamView.foobar] [@vm.inferred-type.metadata=!? (skip check)] x.{self::Stream::foobar}(#C1, onError: #C1);
+ [@vm.direct-call.metadata=#lib::StreamView.foobar] [@vm.inferred-type.metadata=!? (skip check)] x.{self::Stream::foobar}();
}
static method round3() → void {
self::Stream* x = new self::_GeneratedStreamImpl::•();
x = new self::ByteStream::•(x);
x = new self::_ControllerStream::•();
- [@vm.direct-call.metadata=#lib::_StreamImpl.foobar] [@vm.inferred-type.metadata=!? (skip check)] x.{self::Stream::foobar}(#C1, onError: #C1);
+ [@vm.direct-call.metadata=#lib::_StreamImpl.foobar] [@vm.inferred-type.metadata=!? (skip check)] x.{self::Stream::foobar}();
}
static method round4() → void {
self::ByteStream* x = new self::ByteStream::•(new self::_ControllerStream::•());
self::Stream* y = [@vm.direct-call.metadata=#lib::ByteStream.super_stream] [@vm.inferred-type.metadata=!] x.{self::ByteStream::super_stream};
self::Stream* z = [@vm.direct-call.metadata=#lib::StreamView._stream] [@vm.inferred-type.metadata=!] x.{self::StreamView::_stream};
if([@vm.direct-call.metadata=dart.core::Object.==] [@vm.inferred-type.metadata=dart.core::bool (skip check)] y.{self::Stream::==}(z)) {
- [@vm.direct-call.metadata=#lib::ByteStream.super_foobar2] [@vm.inferred-type.metadata=!? (skip check)] x.{self::ByteStream::super_foobar2}(#C1);
+ [@vm.direct-call.metadata=#lib::ByteStream.super_foobar2] [@vm.inferred-type.metadata=!? (skip check)] x.{self::ByteStream::super_foobar2}();
}
}
static method round5() → void {
diff --git a/pkg/vm/testcases/transformations/type_flow/transformer/lists.dart.expect b/pkg/vm/testcases/transformations/type_flow/transformer/lists.dart.expect
index 0fd6e10..c02e36d 100644
--- a/pkg/vm/testcases/transformations/type_flow/transformer/lists.dart.expect
+++ b/pkg/vm/testcases/transformations/type_flow/transformer/lists.dart.expect
@@ -11,7 +11,7 @@
[@vm.inferred-type.metadata=dart.core::_GrowableList<dart.core::int*>] [@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:5] final field core::List<core::int*>* defaultConstructor1 = [@vm.inferred-type.metadata=dart.core::_GrowableList<dart.core::int*>] core::_GrowableList::•<core::int*>(0);
[@vm.inferred-type.metadata=dart.core::_List<dart.core::int*>] [@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:6] final field core::List<core::int*>* defaultConstructor2 = [@vm.inferred-type.metadata=dart.core::_List<dart.core::int*>] core::_List::•<core::int*>(3);
[@vm.inferred-type.metadata=dart.core::_List<dart.core::int*>] [@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:7] final field core::List<core::int*>* filledFactory1 = [@vm.inferred-type.metadata=dart.core::_List<dart.core::int*>] core::_List::filled<core::int*>(2, 0);
-[@vm.inferred-type.metadata=dart.core::_GrowableList<dart.core::int*>] [@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:8] final field core::List<core::int*>* filledFactory2 = [@vm.inferred-type.metadata=dart.core::_GrowableList<dart.core::int*>] core::_GrowableList::filled<core::int*>(2, 0);
+[@vm.inferred-type.metadata=dart.core::_GrowableList<dart.core::int*>] [@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:8] final field core::List<core::int*>* filledFactory2 = [@vm.inferred-type.metadata=dart.core::_GrowableList<dart.core::int*>] core::_GrowableList::filled<core::int*>();
[@vm.inferred-type.metadata=dart.core::_List<dart.core::int*>] [@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:9] final field core::List<core::int*>* filledFactory3 = [@vm.inferred-type.metadata=dart.core::_List<dart.core::int*>] core::_List::filled<core::int*>(2, 0);
[@vm.inferred-type.metadata=!] [@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:10] final field core::List<core::int*>* filledFactory4 = let final core::bool #t1 = _in::unsafeCast<core::bool>([@vm.inferred-type.metadata=dart.core::bool] self::nonConstant()) in [@vm.inferred-type.metadata=!] core::List::filled<core::int*>(2, 0, #t1);
[@vm.inferred-type.metadata=dart.core::_List<dart.core::int*>] [@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:11] final field core::List<core::int*>* filledFactory5 = [@vm.inferred-type.metadata=dart.core::_List<dart.core::int*>] core::_List::•<core::int*>(2);
@@ -20,8 +20,8 @@
[@vm.inferred-type.metadata=!] [@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:14] final field core::List<core::int*>* filledFactory8 = let final core::bool #t2 = _in::unsafeCast<core::bool>([@vm.inferred-type.metadata=dart.core::bool] self::nonConstant()) in [@vm.inferred-type.metadata=!] core::List::filled<core::int*>(2, null, #t2);
[@vm.inferred-type.metadata=dart.core::_GrowableList<dart.core::int*>] [@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:15] final field core::List<core::int*>* generateFactory1 = [@vm.inferred-type.metadata=dart.core::_GrowableList<dart.core::int*>] core::_GrowableList::generate<core::int*>(2, (core::int* i) → core::int* => i);
[@vm.inferred-type.metadata=dart.core::_GrowableList<dart.core::int*>] [@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:16] final field core::List<core::int*>* generateFactory2 = [@vm.inferred-type.metadata=dart.core::_GrowableList<dart.core::int*>] core::_GrowableList::generate<core::int*>(2, (core::int* i) → core::int* => i);
-[@vm.inferred-type.metadata=dart.core::_List<dart.core::int*>] [@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:17] final field core::List<core::int*>* generateFactory3 = [@vm.inferred-type.metadata=dart.core::_List<dart.core::int*>] core::_List::generate<core::int*>(2, (core::int* i) → core::int* => i);
-[@vm.inferred-type.metadata=!] [@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:18] final field core::List<core::int*>* generateFactory4 = let final (core::int*) →* core::int* #t3 = (core::int* i) → core::int* => i in let final core::bool #t4 = _in::unsafeCast<core::bool>([@vm.inferred-type.metadata=dart.core::bool] self::nonConstant()) in [@vm.inferred-type.metadata=!] core::List::generate<core::int*>(2, #t3, #t4);
+[@vm.inferred-type.metadata=dart.core::_List<dart.core::int*>] [@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:17] final field core::List<core::int*>* generateFactory3 = [@vm.inferred-type.metadata=dart.core::_List<dart.core::int*>] core::_List::generate<core::int*>((core::int* i) → core::int* => i);
+[@vm.inferred-type.metadata=!] [@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:18] final field core::List<core::int*>* generateFactory4 = let final (core::int*) →* core::int* #t3 = (core::int* i) → core::int* => i in let final core::bool #t4 = _in::unsafeCast<core::bool>([@vm.inferred-type.metadata=dart.core::bool] self::nonConstant()) in [@vm.inferred-type.metadata=!] core::List::generate<core::int*>(#t3, #t4);
[@vm.inferred-type.metadata=dart.core::_GrowableList<dart.core::List<dart.core::int*>*>] [@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:19] final field core::List<core::List<core::int*>*>* generateFactory5 = [@vm.inferred-type.metadata=dart.core::_GrowableList<dart.core::List<dart.core::int*>*>] core::_GrowableList::generate<core::List<core::int*>*>(2, (core::int* _) → core::List<core::int*>* => <core::int*>[]);
synthetic constructor •() → self::A*
: super core::Object::•()
diff --git a/pkg/vm/testcases/transformations/type_flow/transformer/lists_nnbd.dart.expect b/pkg/vm/testcases/transformations/type_flow/transformer/lists_nnbd.dart.expect
index 8a54bb1..8d53437 100644
--- a/pkg/vm/testcases/transformations/type_flow/transformer/lists_nnbd.dart.expect
+++ b/pkg/vm/testcases/transformations/type_flow/transformer/lists_nnbd.dart.expect
@@ -9,7 +9,7 @@
[@vm.inferred-type.metadata=dart.core::_ImmutableList (value: const <dart.core::int*>[])] [@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:3] final field core::List<core::int> constLiteral1 = #C1;
[@vm.inferred-type.metadata=dart.core::_ImmutableList (value: const <dart.core::int*>[1, 2])] [@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:4] final field core::List<core::int> constLiteral2 = #C4;
[@vm.inferred-type.metadata=dart.core::_List<dart.core::int>] [@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:5] final field core::List<core::int> filledFactory1 = [@vm.inferred-type.metadata=dart.core::_List<dart.core::int>] core::_List::filled<core::int>(2, 0);
-[@vm.inferred-type.metadata=dart.core::_GrowableList<dart.core::int>] [@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:6] final field core::List<core::int> filledFactory2 = [@vm.inferred-type.metadata=dart.core::_GrowableList<dart.core::int>] core::_GrowableList::filled<core::int>(2, 0);
+[@vm.inferred-type.metadata=dart.core::_GrowableList<dart.core::int>] [@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:6] final field core::List<core::int> filledFactory2 = [@vm.inferred-type.metadata=dart.core::_GrowableList<dart.core::int>] core::_GrowableList::filled<core::int>();
[@vm.inferred-type.metadata=dart.core::_List<dart.core::int>] [@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:7] final field core::List<core::int> filledFactory3 = [@vm.inferred-type.metadata=dart.core::_List<dart.core::int>] core::_List::filled<core::int>(2, 0);
[@vm.inferred-type.metadata=!] [@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:8] final field core::List<core::int> filledFactory4 = let final core::bool #t1 = _in::unsafeCast<core::bool>([@vm.inferred-type.metadata=dart.core::bool] self::nonConstant()) in [@vm.inferred-type.metadata=!] core::List::filled<core::int>(2, 0, #t1);
[@vm.inferred-type.metadata=dart.core::_List<dart.core::int?>] [@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:9] final field core::List<core::int?> filledFactory5 = [@vm.inferred-type.metadata=dart.core::_List<dart.core::int?>] core::_List::•<core::int?>(2);
@@ -18,8 +18,8 @@
[@vm.inferred-type.metadata=!] [@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:12] final field core::List<core::int?> filledFactory8 = let final core::bool #t2 = _in::unsafeCast<core::bool>([@vm.inferred-type.metadata=dart.core::bool] self::nonConstant()) in [@vm.inferred-type.metadata=!] core::List::filled<core::int?>(2, null, #t2);
[@vm.inferred-type.metadata=dart.core::_GrowableList<dart.core::int>] [@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:13] final field core::List<core::int> generateFactory1 = [@vm.inferred-type.metadata=dart.core::_GrowableList<dart.core::int>] core::_GrowableList::generate<core::int>(2, (core::int i) → core::int => i);
[@vm.inferred-type.metadata=dart.core::_GrowableList<dart.core::int>] [@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:14] final field core::List<core::int> generateFactory2 = [@vm.inferred-type.metadata=dart.core::_GrowableList<dart.core::int>] core::_GrowableList::generate<core::int>(2, (core::int i) → core::int => i);
-[@vm.inferred-type.metadata=dart.core::_List<dart.core::int>] [@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:15] final field core::List<core::int> generateFactory3 = [@vm.inferred-type.metadata=dart.core::_List<dart.core::int>] core::_List::generate<core::int>(2, (core::int i) → core::int => i);
-[@vm.inferred-type.metadata=!] [@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:16] final field core::List<core::int> generateFactory4 = let final (core::int) → core::int #t3 = (core::int i) → core::int => i in let final core::bool #t4 = _in::unsafeCast<core::bool>([@vm.inferred-type.metadata=dart.core::bool] self::nonConstant()) in [@vm.inferred-type.metadata=!] core::List::generate<core::int>(2, #t3, #t4);
+[@vm.inferred-type.metadata=dart.core::_List<dart.core::int>] [@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:15] final field core::List<core::int> generateFactory3 = [@vm.inferred-type.metadata=dart.core::_List<dart.core::int>] core::_List::generate<core::int>((core::int i) → core::int => i);
+[@vm.inferred-type.metadata=!] [@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:16] final field core::List<core::int> generateFactory4 = let final (core::int) → core::int #t3 = (core::int i) → core::int => i in let final core::bool #t4 = _in::unsafeCast<core::bool>([@vm.inferred-type.metadata=dart.core::bool] self::nonConstant()) in [@vm.inferred-type.metadata=!] core::List::generate<core::int>(#t3, #t4);
[@vm.inferred-type.metadata=dart.core::_GrowableList<dart.core::List<dart.core::int>>] [@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:17] final field core::List<core::List<core::int>> generateFactory5 = [@vm.inferred-type.metadata=dart.core::_GrowableList<dart.core::List<dart.core::int>>] core::_GrowableList::generate<core::List<core::int>>(2, (core::int _) → core::List<core::int> => <core::int>[]);
synthetic constructor •() → self::A
: super core::Object::•()
diff --git a/pkg/vm/testcases/transformations/type_flow/transformer/null_check_elimination_nnbd.dart.expect b/pkg/vm/testcases/transformations/type_flow/transformer/null_check_elimination_nnbd.dart.expect
index d80f88a..1b24ebc 100644
--- a/pkg/vm/testcases/transformations/type_flow/transformer/null_check_elimination_nnbd.dart.expect
+++ b/pkg/vm/testcases/transformations/type_flow/transformer/null_check_elimination_nnbd.dart.expect
@@ -7,8 +7,8 @@
[@vm.inferred-type.metadata=dart.core::_OneByteString] [@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:1,getterSelectorId:2] field core::String? nonNullable;
[@vm.inferred-type.metadata=dart.core::_OneByteString?] [@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:3,getterSelectorId:4] field core::String? nullable;
[@vm.inferred-type.metadata=dart.core::Null? (value: null)] [@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:5,getterSelectorId:6] field core::String? alwaysNull;
- constructor •([@vm.inferred-type.metadata=dart.core::_OneByteString] core::String? nonNullable, [@vm.inferred-type.metadata=dart.core::_OneByteString?] core::String? nullable, {[@vm.inferred-type.metadata=dart.core::Null? (value: null)] core::String? alwaysNull = #C1}) → self::A
- : self::A::nonNullable = nonNullable, self::A::nullable = nullable, self::A::alwaysNull = alwaysNull, super core::Object::•()
+ constructor •([@vm.inferred-type.metadata=dart.core::_OneByteString] core::String? nonNullable, [@vm.inferred-type.metadata=dart.core::_OneByteString?] core::String? nullable) → self::A
+ : self::A::nonNullable = nonNullable, self::A::nullable = nullable, self::A::alwaysNull = #C1, super core::Object::•()
;
}
[@vm.inferred-type.metadata=#lib::A?]static field self::A staticField = new self::A::•("hi", "bye");
@@ -19,7 +19,7 @@
static method testAlwaysNull([@vm.inferred-type.metadata=#lib::A?] self::A a) → dynamic
return [@vm.direct-call.metadata=#lib::A.alwaysNull??] [@vm.inferred-type.metadata=dart.core::Null? (value: null)] a.{self::A::alwaysNull}!;
static method main() → void {
- final core::List<self::A> list = <self::A>[new self::A::•("foo", null, alwaysNull: null), self::staticField];
+ final core::List<self::A> list = <self::A>[new self::A::•("foo", null), self::staticField];
{
core::Iterator<self::A> :sync-for-iterator = [@vm.direct-call.metadata=dart.core::_GrowableList.iterator] [@vm.inferred-type.metadata=dart._internal::ListIterator<#lib::A>] list.{core::Iterable::iterator};
for (; [@vm.direct-call.metadata=dart._internal::ListIterator.moveNext] [@vm.inferred-type.metadata=dart.core::bool (skip check)] :sync-for-iterator.{core::Iterator::moveNext}(); ) {
diff --git a/pkg/vm/testcases/transformations/type_flow/transformer/null_test_elimination.dart.expect b/pkg/vm/testcases/transformations/type_flow/transformer/null_test_elimination.dart.expect
index 615c0d7..17ed46c 100644
--- a/pkg/vm/testcases/transformations/type_flow/transformer/null_test_elimination.dart.expect
+++ b/pkg/vm/testcases/transformations/type_flow/transformer/null_test_elimination.dart.expect
@@ -7,8 +7,8 @@
[@vm.inferred-type.metadata=dart.core::_OneByteString] [@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:1,getterSelectorId:2] field core::String* nonNullable;
[@vm.inferred-type.metadata=dart.core::_OneByteString?] [@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:3,getterSelectorId:4] field core::String* nullable;
[@vm.inferred-type.metadata=dart.core::Null? (value: null)] [@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:5,getterSelectorId:6] field core::String* alwaysNull;
- constructor •([@vm.inferred-type.metadata=dart.core::_OneByteString] core::String* nonNullable, [@vm.inferred-type.metadata=dart.core::_OneByteString?] core::String* nullable, {[@vm.inferred-type.metadata=dart.core::Null? (value: null)] core::String* alwaysNull = #C1}) → self::A*
- : self::A::nonNullable = nonNullable, self::A::nullable = nullable, self::A::alwaysNull = alwaysNull, super core::Object::•()
+ constructor •([@vm.inferred-type.metadata=dart.core::_OneByteString] core::String* nonNullable, [@vm.inferred-type.metadata=dart.core::_OneByteString?] core::String* nullable) → self::A*
+ : self::A::nonNullable = nonNullable, self::A::nullable = nullable, self::A::alwaysNull = #C1, super core::Object::•()
;
}
[@vm.inferred-type.metadata=#lib::A?]static field self::A* staticField = new self::A::•("hi", "bye");
@@ -51,7 +51,7 @@
static method someCondition() → dynamic
return [@vm.direct-call.metadata=dart.core::_IntegerImplementation.==] [@vm.inferred-type.metadata=dart.core::bool (skip check)] [@vm.inferred-type.metadata=int] core::int::parse("1").{core::num::==}(1);
static method main() → void {
- final core::List<self::A*>* list = <self::A*>[new self::A::•("foo", null, alwaysNull: null), self::staticField];
+ final core::List<self::A*>* list = <self::A*>[new self::A::•("foo", null), self::staticField];
{
core::Iterator<self::A*>* :sync-for-iterator = [@vm.direct-call.metadata=dart.core::_GrowableList.iterator] [@vm.inferred-type.metadata=dart._internal::ListIterator<#lib::A*>] list.{core::Iterable::iterator};
for (; [@vm.direct-call.metadata=dart._internal::ListIterator.moveNext] [@vm.inferred-type.metadata=dart.core::bool (skip check)] :sync-for-iterator.{core::Iterator::moveNext}(); ) {
diff --git a/pkg/vm/testcases/transformations/type_flow/transformer/protobuf_handler/lib/create_test.dart.expect b/pkg/vm/testcases/transformations/type_flow/transformer/protobuf_handler/lib/create_test.dart.expect
index 3c20021..a697cdd 100644
--- a/pkg/vm/testcases/transformations/type_flow/transformer/protobuf_handler/lib/create_test.dart.expect
+++ b/pkg/vm/testcases/transformations/type_flow/transformer/protobuf_handler/lib/create_test.dart.expect
@@ -18,7 +18,7 @@
} =>#t3);
[@vm.direct-call.metadata=library file:pkg/vm/testcases/transformations/type_flow/transformer/protobuf_handler/lib/generated/foo.pb.dart::FooKeep.aKeep] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pb::FooKeep::aKeep} = 43;
} =>#t1;
- tes::test("retrieving values", () → Null {
+ tes::test(() → Null {
exp::expect([@vm.direct-call.metadata=library file:pkg/vm/testcases/transformations/type_flow/transformer/protobuf_handler/lib/generated/foo.pb.dart::BarKeep.aKeep??] [@vm.inferred-type.metadata=int] [@vm.direct-call.metadata=library file:pkg/vm/testcases/transformations/type_flow/transformer/protobuf_handler/lib/generated/foo.pb.dart::FooKeep.barKeep] [@vm.inferred-type.metadata=library file:pkg/vm/testcases/transformations/type_flow/transformer/protobuf_handler/lib/generated/foo.pb.dart::BarKeep?] foo.{pb::FooKeep::barKeep}.{pb::BarKeep::aKeep}, 5);
exp::expect([@vm.direct-call.metadata=library file:pkg/vm/testcases/transformations/type_flow/transformer/protobuf_handler/lib/generated/foo.pb.dart::BarKeep.aKeep??] [@vm.inferred-type.metadata=int] [@vm.inferred-type.metadata=library file:pkg/vm/testcases/transformations/type_flow/transformer/protobuf_handler/lib/generated/foo.pb.dart::BarKeep?] [@vm.direct-call.metadata=library file:pkg/vm/testcases/transformations/type_flow/transformer/protobuf_handler/lib/generated/foo.pb.dart::FooKeep.mapKeep] [@vm.inferred-type.metadata=!] foo.{pb::FooKeep::mapKeep}.{core::Map::[]}("foo").{pb::BarKeep::aKeep}, 2);
exp::expect([@vm.direct-call.metadata=library file:pkg/vm/testcases/transformations/type_flow/transformer/protobuf_handler/lib/generated/foo.pb.dart::FooKeep.hasHasKeep] [@vm.inferred-type.metadata=dart.core::bool (skip check)] foo.{pb::FooKeep::hasHasKeep}(), false);
@@ -38,11 +38,11 @@
[@vm.inferred-type.metadata=protobuf::BuilderInfo?] static final field pro::BuilderInfo _i = let final pro::BuilderInfo #t1 = new pro::BuilderInfo::•((#C1) ?{core::String} "" : "FooKeep") in block {
[@vm.direct-call.metadata=protobuf::BuilderInfo.aOM] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pro::BuilderInfo::aOM}<self::BarKeep>(1, (#C1) ?{core::String} "" : "barKeep", "barKeep", #C2);
[@vm.direct-call.metadata=protobuf::BuilderInfo.add] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pro::BuilderInfo::add}<Null>(0, null, null, null, null, null, null);
- [@vm.direct-call.metadata=protobuf::BuilderInfo.m] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pro::BuilderInfo::m}<core::String, self::BarKeep>(3, (#C1) ?{core::String} "" : "mapKeep", "FooKeep.MapKeepEntry", #C3, "mapKeep", #C2, #C4);
+ [@vm.direct-call.metadata=protobuf::BuilderInfo.m] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pro::BuilderInfo::m}<core::String, self::BarKeep>(3, (#C1) ?{core::String} "" : "mapKeep", #C2);
[@vm.direct-call.metadata=protobuf::BuilderInfo.add] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pro::BuilderInfo::add}<Null>(0, null, null, null, null, null, null);
- [@vm.direct-call.metadata=protobuf::BuilderInfo.a] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pro::BuilderInfo::a}<core::int>(5, (#C1) ?{core::String} "" : "aKeep", #C5, "aKeep");
- [@vm.direct-call.metadata=protobuf::BuilderInfo.aOM] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pro::BuilderInfo::aOM}<self::HasKeep>(6, (#C1) ?{core::String} "" : "hasKeep", "hasKeep", #C6);
- [@vm.direct-call.metadata=protobuf::BuilderInfo.aOM] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pro::BuilderInfo::aOM}<self::ClearKeep>(7, (#C1) ?{core::String} "" : "clearKeep", "clearKeep", #C7);
+ [@vm.direct-call.metadata=protobuf::BuilderInfo.a] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pro::BuilderInfo::a}<core::int>(5, (#C1) ?{core::String} "" : "aKeep", #C3);
+ [@vm.direct-call.metadata=protobuf::BuilderInfo.aOM] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pro::BuilderInfo::aOM}<self::HasKeep>(6, (#C1) ?{core::String} "" : "hasKeep", "hasKeep", #C4);
+ [@vm.direct-call.metadata=protobuf::BuilderInfo.aOM] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pro::BuilderInfo::aOM}<self::ClearKeep>(7, (#C1) ?{core::String} "" : "clearKeep", "clearKeep", #C5);
[@vm.direct-call.metadata=protobuf::BuilderInfo.hasRequiredFields] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pro::BuilderInfo::hasRequiredFields} = false;
} =>#t1;
constructor _() → self::FooKeep
@@ -52,36 +52,36 @@
return [@vm.inferred-type.metadata=foo.pb.dart::FooKeep] self::FooKeep::create();
[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:1] get info_() → pro::BuilderInfo
return [@vm.inferred-type.metadata=protobuf::BuilderInfo?] self::FooKeep::_i;
- @#C10
+ @#C8
static method create() → self::FooKeep
return new self::FooKeep::_();
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:2,getterSelectorId:3] @#C12
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:2,getterSelectorId:3] @#C10
get barKeep() → self::BarKeep
- return [@vm.direct-call.metadata=protobuf::GeneratedMessage.$_getN] [@vm.inferred-type.metadata=foo.pb.dart::BarKeep? (skip check)] this.{pro::GeneratedMessage::$_getN}<self::BarKeep>(0);
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:2,getterSelectorId:3] @#C12
+ return [@vm.direct-call.metadata=protobuf::GeneratedMessage.$_getN] [@vm.inferred-type.metadata=foo.pb.dart::BarKeep? (skip check)] this.{pro::GeneratedMessage::$_getN}<self::BarKeep>();
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:2,getterSelectorId:3] @#C10
set barKeep([@vm.inferred-type.metadata=foo.pb.dart::BarKeep] self::BarKeep v) → void {
- [@vm.direct-call.metadata=protobuf::GeneratedMessage.setField] [@vm.inferred-type.metadata=!? (skip check)] this.{pro::GeneratedMessage::setField}(1, v);
+ [@vm.direct-call.metadata=protobuf::GeneratedMessage.setField] [@vm.inferred-type.metadata=!? (skip check)] this.{pro::GeneratedMessage::setField}(v);
}
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:4] @#C14
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:4] @#C12
get mapKeep() → core::Map<core::String, self::BarKeep>
- return [@vm.direct-call.metadata=protobuf::GeneratedMessage.$_getMap] [@vm.inferred-type.metadata=! (skip check)] this.{pro::GeneratedMessage::$_getMap}<core::String, self::BarKeep>(2);
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:5,getterSelectorId:6] [@vm.unboxing-info.metadata=()->i] @#C16
+ return [@vm.direct-call.metadata=protobuf::GeneratedMessage.$_getMap] [@vm.inferred-type.metadata=! (skip check)] this.{pro::GeneratedMessage::$_getMap}<core::String, self::BarKeep>();
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:5,getterSelectorId:6] [@vm.unboxing-info.metadata=()->i] @#C14
get aKeep() → core::int
return [@vm.direct-call.metadata=protobuf::GeneratedMessage.$_getIZ] [@vm.inferred-type.metadata=int (skip check)] this.{pro::GeneratedMessage::$_getIZ}(4);
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:5,getterSelectorId:6] [@vm.unboxing-info.metadata=(i)->b] @#C16
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:5,getterSelectorId:6] [@vm.unboxing-info.metadata=(i)->b] @#C14
set aKeep([@vm.inferred-type.metadata=dart.core::_Smi (value: 43)] core::int v) → void {
[@vm.direct-call.metadata=protobuf::GeneratedMessage.$_setSignedInt32] [@vm.inferred-type.metadata=!? (skip check)] this.{pro::GeneratedMessage::$_setSignedInt32}(4, v);
}
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:7,getterSelectorId:8] @#C18
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:7,getterSelectorId:8] @#C16
method hasHasKeep() → core::bool
- return [@vm.direct-call.metadata=protobuf::GeneratedMessage.$_has] [@vm.inferred-type.metadata=dart.core::bool (skip check)] this.{pro::GeneratedMessage::$_has}(5);
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:9,getterSelectorId:10] @#C20
+ return [@vm.direct-call.metadata=protobuf::GeneratedMessage.$_has] [@vm.inferred-type.metadata=dart.core::bool (skip check)] this.{pro::GeneratedMessage::$_has}();
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:9,getterSelectorId:10] @#C18
method clearClearKeep() → void
- return [@vm.direct-call.metadata=protobuf::GeneratedMessage.clearField] [@vm.inferred-type.metadata=dart.core::Null? (skip check) (value: null)] this.{pro::GeneratedMessage::clearField}(7);
+ return [@vm.direct-call.metadata=protobuf::GeneratedMessage.clearField] [@vm.inferred-type.metadata=dart.core::Null? (skip check) (value: null)] this.{pro::GeneratedMessage::clearField}();
}
class BarKeep extends pro::GeneratedMessage {
[@vm.inferred-type.metadata=protobuf::BuilderInfo?] static final field pro::BuilderInfo _i = let final pro::BuilderInfo #t2 = new pro::BuilderInfo::•((#C1) ?{core::String} "" : "BarKeep") in block {
- [@vm.direct-call.metadata=protobuf::BuilderInfo.a] [@vm.inferred-type.metadata=!? (skip check)] #t2.{pro::BuilderInfo::a}<core::int>(1, (#C1) ?{core::String} "" : "aKeep", #C5, "aKeep");
+ [@vm.direct-call.metadata=protobuf::BuilderInfo.a] [@vm.inferred-type.metadata=!? (skip check)] #t2.{pro::BuilderInfo::a}<core::int>(1, (#C1) ?{core::String} "" : "aKeep", #C3);
[@vm.direct-call.metadata=protobuf::BuilderInfo.add] [@vm.inferred-type.metadata=!? (skip check)] #t2.{pro::BuilderInfo::add}<Null>(0, null, null, null, null, null, null);
[@vm.direct-call.metadata=protobuf::BuilderInfo.hasRequiredFields] [@vm.inferred-type.metadata=!? (skip check)] #t2.{pro::BuilderInfo::hasRequiredFields} = false;
} =>#t2;
@@ -92,13 +92,13 @@
return [@vm.inferred-type.metadata=foo.pb.dart::BarKeep] self::BarKeep::create();
[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:1] get info_() → pro::BuilderInfo
return [@vm.inferred-type.metadata=protobuf::BuilderInfo?] self::BarKeep::_i;
- @#C10
+ @#C8
static method create() → self::BarKeep
return new self::BarKeep::_();
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:11,getterSelectorId:12] [@vm.unboxing-info.metadata=()->i] @#C12
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:11,getterSelectorId:12] [@vm.unboxing-info.metadata=()->i] @#C10
get aKeep() → core::int
return [@vm.direct-call.metadata=protobuf::GeneratedMessage.$_getIZ] [@vm.inferred-type.metadata=int (skip check)] this.{pro::GeneratedMessage::$_getIZ}(0);
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:11,getterSelectorId:12] [@vm.unboxing-info.metadata=(i)->b] @#C12
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:11,getterSelectorId:12] [@vm.unboxing-info.metadata=(i)->b] @#C10
set aKeep([@vm.inferred-type.metadata=dart.core::_Smi] core::int v) → void {
[@vm.direct-call.metadata=protobuf::GeneratedMessage.$_setSignedInt32] [@vm.inferred-type.metadata=!? (skip check)] this.{pro::GeneratedMessage::$_setSignedInt32}(0, v);
}
@@ -113,7 +113,7 @@
;
[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:1] get info_() → pro::BuilderInfo
return [@vm.inferred-type.metadata=protobuf::BuilderInfo?] self::HasKeep::_i;
- @#C10
+ @#C8
static method create() → self::HasKeep
return new self::HasKeep::_();
}
@@ -127,7 +127,7 @@
;
[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:1] get info_() → pro::BuilderInfo
return [@vm.inferred-type.metadata=protobuf::BuilderInfo?] self::ClearKeep::_i;
- @#C10
+ @#C8
static method create() → self::ClearKeep
return new self::ClearKeep::_();
}
diff --git a/pkg/vm/testcases/transformations/type_flow/transformer/protobuf_handler/lib/decode_test.dart.expect b/pkg/vm/testcases/transformations/type_flow/transformer/protobuf_handler/lib/decode_test.dart.expect
index 73d4dc4..14a4689 100644
--- a/pkg/vm/testcases/transformations/type_flow/transformer/protobuf_handler/lib/decode_test.dart.expect
+++ b/pkg/vm/testcases/transformations/type_flow/transformer/protobuf_handler/lib/decode_test.dart.expect
@@ -11,7 +11,7 @@
[@vm.inferred-type.metadata=dart.core::_GrowableList?<dart.core::int*>]static field core::List<core::int*>* buffer = <core::int*>[10, 4, 8, 5, 16, 4, 26, 9, 10, 3, 102, 111, 111, 18, 2, 8, 42, 34, 9, 10, 3, 122, 111, 112, 18, 2, 8, 3, 40, 43, 50, 0, 58, 0];
static method main() → dynamic {
pb::FooKeep* foo = [@vm.inferred-type.metadata=library file:pkg/vm/testcases/transformations/type_flow/transformer/protobuf_handler/lib/generated/foo.pb.dart::FooKeep] pb::FooKeep::fromBuffer([@vm.inferred-type.metadata=dart.core::_GrowableList?<dart.core::int*>] self::buffer);
- tes::test("Kept values are restored correctly", () → Null {
+ tes::test(() → Null {
exp::expect([@vm.direct-call.metadata=library file:pkg/vm/testcases/transformations/type_flow/transformer/protobuf_handler/lib/generated/foo.pb.dart::BarKeep.aKeep??] [@vm.inferred-type.metadata=int] [@vm.inferred-type.metadata=library file:pkg/vm/testcases/transformations/type_flow/transformer/protobuf_handler/lib/generated/foo.pb.dart::BarKeep?] [@vm.direct-call.metadata=library file:pkg/vm/testcases/transformations/type_flow/transformer/protobuf_handler/lib/generated/foo.pb.dart::FooKeep.mapKeep] [@vm.inferred-type.metadata=!] foo.{pb::FooKeep::mapKeep}.{core::Map::[]}("foo").{pb::BarKeep::aKeep}, 42);
exp::expect([@vm.direct-call.metadata=library file:pkg/vm/testcases/transformations/type_flow/transformer/protobuf_handler/lib/generated/foo.pb.dart::BarKeep.aKeep??] [@vm.inferred-type.metadata=int] [@vm.direct-call.metadata=library file:pkg/vm/testcases/transformations/type_flow/transformer/protobuf_handler/lib/generated/foo.pb.dart::FooKeep.barKeep] [@vm.inferred-type.metadata=library file:pkg/vm/testcases/transformations/type_flow/transformer/protobuf_handler/lib/generated/foo.pb.dart::BarKeep?] foo.{pb::FooKeep::barKeep}.{pb::BarKeep::aKeep}, 5);
exp::expect([@vm.direct-call.metadata=library file:pkg/vm/testcases/transformations/type_flow/transformer/protobuf_handler/lib/generated/foo.pb.dart::FooKeep.aKeep] [@vm.inferred-type.metadata=int] foo.{pb::FooKeep::aKeep}, 43);
@@ -31,11 +31,11 @@
[@vm.inferred-type.metadata=protobuf::BuilderInfo?] static final field pro::BuilderInfo _i = let final pro::BuilderInfo #t1 = new pro::BuilderInfo::•((#C1) ?{core::String} "" : "FooKeep", createEmptyInstance: #C2) in block {
[@vm.direct-call.metadata=protobuf::BuilderInfo.aOM] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pro::BuilderInfo::aOM}<self::BarKeep>(1, (#C1) ?{core::String} "" : "barKeep", "barKeep", #C3);
[@vm.direct-call.metadata=protobuf::BuilderInfo.add] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pro::BuilderInfo::add}<Null>(0, null, null, null, null, null, null);
- [@vm.direct-call.metadata=protobuf::BuilderInfo.m] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pro::BuilderInfo::m}<core::String, self::BarKeep>(3, (#C1) ?{core::String} "" : "mapKeep", "FooKeep.MapKeepEntry", #C4, "mapKeep", #C3, #C5);
+ [@vm.direct-call.metadata=protobuf::BuilderInfo.m] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pro::BuilderInfo::m}<core::String, self::BarKeep>(3, (#C1) ?{core::String} "" : "mapKeep", #C3);
[@vm.direct-call.metadata=protobuf::BuilderInfo.add] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pro::BuilderInfo::add}<Null>(0, null, null, null, null, null, null);
- [@vm.direct-call.metadata=protobuf::BuilderInfo.a] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pro::BuilderInfo::a}<core::int>(5, (#C1) ?{core::String} "" : "aKeep", #C6, "aKeep");
- [@vm.direct-call.metadata=protobuf::BuilderInfo.aOM] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pro::BuilderInfo::aOM}<self::HasKeep>(6, (#C1) ?{core::String} "" : "hasKeep", "hasKeep", #C7);
- [@vm.direct-call.metadata=protobuf::BuilderInfo.aOM] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pro::BuilderInfo::aOM}<self::ClearKeep>(7, (#C1) ?{core::String} "" : "clearKeep", "clearKeep", #C8);
+ [@vm.direct-call.metadata=protobuf::BuilderInfo.a] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pro::BuilderInfo::a}<core::int>(5, (#C1) ?{core::String} "" : "aKeep", #C4);
+ [@vm.direct-call.metadata=protobuf::BuilderInfo.aOM] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pro::BuilderInfo::aOM}<self::HasKeep>(6, (#C1) ?{core::String} "" : "hasKeep", "hasKeep", #C5);
+ [@vm.direct-call.metadata=protobuf::BuilderInfo.aOM] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pro::BuilderInfo::aOM}<self::ClearKeep>(7, (#C1) ?{core::String} "" : "clearKeep", "clearKeep", #C6);
[@vm.direct-call.metadata=protobuf::BuilderInfo.hasRequiredFields] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pro::BuilderInfo::hasRequiredFields} = false;
} =>#t1;
constructor _() → self::FooKeep
@@ -43,32 +43,32 @@
;
static factory fromBuffer([@vm.inferred-type.metadata=dart.core::_GrowableList?<dart.core::int*>] core::List<core::int> i) → self::FooKeep
return let final self::FooKeep #t2 = [@vm.inferred-type.metadata=foo.pb.dart::FooKeep] self::FooKeep::create() in block {
- [@vm.direct-call.metadata=protobuf::GeneratedMessage.mergeFromBuffer] [@vm.inferred-type.metadata=!? (skip check)] #t2.{pro::GeneratedMessage::mergeFromBuffer}(i, #C9);
+ [@vm.direct-call.metadata=protobuf::GeneratedMessage.mergeFromBuffer] [@vm.inferred-type.metadata=!? (skip check)] #t2.{pro::GeneratedMessage::mergeFromBuffer}(i);
} =>#t2;
[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:1] get info_() → pro::BuilderInfo
return [@vm.inferred-type.metadata=protobuf::BuilderInfo?] self::FooKeep::_i;
- @#C12
+ @#C9
static method create() → self::FooKeep
return new self::FooKeep::_();
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:2] @#C14
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:2] @#C11
get barKeep() → self::BarKeep
- return [@vm.direct-call.metadata=protobuf::GeneratedMessage.$_getN] [@vm.inferred-type.metadata=foo.pb.dart::BarKeep? (skip check)] this.{pro::GeneratedMessage::$_getN}<self::BarKeep>(0);
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:3] @#C16
+ return [@vm.direct-call.metadata=protobuf::GeneratedMessage.$_getN] [@vm.inferred-type.metadata=foo.pb.dart::BarKeep? (skip check)] this.{pro::GeneratedMessage::$_getN}<self::BarKeep>();
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:3] @#C13
get mapKeep() → core::Map<core::String, self::BarKeep>
- return [@vm.direct-call.metadata=protobuf::GeneratedMessage.$_getMap] [@vm.inferred-type.metadata=! (skip check)] this.{pro::GeneratedMessage::$_getMap}<core::String, self::BarKeep>(2);
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:4] [@vm.unboxing-info.metadata=()->i] @#C18
+ return [@vm.direct-call.metadata=protobuf::GeneratedMessage.$_getMap] [@vm.inferred-type.metadata=! (skip check)] this.{pro::GeneratedMessage::$_getMap}<core::String, self::BarKeep>();
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:4] [@vm.unboxing-info.metadata=()->i] @#C15
get aKeep() → core::int
return [@vm.direct-call.metadata=protobuf::GeneratedMessage.$_getIZ] [@vm.inferred-type.metadata=int (skip check)] this.{pro::GeneratedMessage::$_getIZ}(4);
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:5,getterSelectorId:6] @#C20
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:5,getterSelectorId:6] @#C17
method hasHasKeep() → core::bool
- return [@vm.direct-call.metadata=protobuf::GeneratedMessage.$_has] [@vm.inferred-type.metadata=dart.core::bool (skip check)] this.{pro::GeneratedMessage::$_has}(5);
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:7,getterSelectorId:8] @#C22
+ return [@vm.direct-call.metadata=protobuf::GeneratedMessage.$_has] [@vm.inferred-type.metadata=dart.core::bool (skip check)] this.{pro::GeneratedMessage::$_has}();
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:7,getterSelectorId:8] @#C19
method clearClearKeep() → void
- return [@vm.direct-call.metadata=protobuf::GeneratedMessage.clearField] [@vm.inferred-type.metadata=dart.core::Null? (skip check) (value: null)] this.{pro::GeneratedMessage::clearField}(7);
+ return [@vm.direct-call.metadata=protobuf::GeneratedMessage.clearField] [@vm.inferred-type.metadata=dart.core::Null? (skip check) (value: null)] this.{pro::GeneratedMessage::clearField}();
}
class BarKeep extends pro::GeneratedMessage {
[@vm.inferred-type.metadata=protobuf::BuilderInfo?] static final field pro::BuilderInfo _i = let final pro::BuilderInfo #t3 = new pro::BuilderInfo::•((#C1) ?{core::String} "" : "BarKeep", createEmptyInstance: #C3) in block {
- [@vm.direct-call.metadata=protobuf::BuilderInfo.a] [@vm.inferred-type.metadata=!? (skip check)] #t3.{pro::BuilderInfo::a}<core::int>(1, (#C1) ?{core::String} "" : "aKeep", #C6, "aKeep");
+ [@vm.direct-call.metadata=protobuf::BuilderInfo.a] [@vm.inferred-type.metadata=!? (skip check)] #t3.{pro::BuilderInfo::a}<core::int>(1, (#C1) ?{core::String} "" : "aKeep", #C4);
[@vm.direct-call.metadata=protobuf::BuilderInfo.add] [@vm.inferred-type.metadata=!? (skip check)] #t3.{pro::BuilderInfo::add}<Null>(0, null, null, null, null, null, null);
[@vm.direct-call.metadata=protobuf::BuilderInfo.hasRequiredFields] [@vm.inferred-type.metadata=!? (skip check)] #t3.{pro::BuilderInfo::hasRequiredFields} = false;
} =>#t3;
@@ -77,15 +77,15 @@
;
[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:1] get info_() → pro::BuilderInfo
return [@vm.inferred-type.metadata=protobuf::BuilderInfo?] self::BarKeep::_i;
- @#C12
+ @#C9
static method create() → self::BarKeep
return new self::BarKeep::_();
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:9] [@vm.unboxing-info.metadata=()->i] @#C14
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:9] [@vm.unboxing-info.metadata=()->i] @#C11
get aKeep() → core::int
return [@vm.direct-call.metadata=protobuf::GeneratedMessage.$_getIZ] [@vm.inferred-type.metadata=int (skip check)] this.{pro::GeneratedMessage::$_getIZ}(0);
}
class HasKeep extends pro::GeneratedMessage {
-[@vm.inferred-type.metadata=protobuf::BuilderInfo?] static final field pro::BuilderInfo _i = let final pro::BuilderInfo #t4 = new pro::BuilderInfo::•((#C1) ?{core::String} "" : "HasKeep", createEmptyInstance: #C7) in block {
+[@vm.inferred-type.metadata=protobuf::BuilderInfo?] static final field pro::BuilderInfo _i = let final pro::BuilderInfo #t4 = new pro::BuilderInfo::•((#C1) ?{core::String} "" : "HasKeep", createEmptyInstance: #C5) in block {
[@vm.direct-call.metadata=protobuf::BuilderInfo.add] [@vm.inferred-type.metadata=!? (skip check)] #t4.{pro::BuilderInfo::add}<Null>(0, null, null, null, null, null, null);
[@vm.direct-call.metadata=protobuf::BuilderInfo.hasRequiredFields] [@vm.inferred-type.metadata=!? (skip check)] #t4.{pro::BuilderInfo::hasRequiredFields} = false;
} =>#t4;
@@ -94,12 +94,12 @@
;
[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:1] get info_() → pro::BuilderInfo
return [@vm.inferred-type.metadata=protobuf::BuilderInfo?] self::HasKeep::_i;
- @#C12
+ @#C9
static method create() → self::HasKeep
return new self::HasKeep::_();
}
class ClearKeep extends pro::GeneratedMessage {
-[@vm.inferred-type.metadata=protobuf::BuilderInfo?] static final field pro::BuilderInfo _i = let final pro::BuilderInfo #t5 = new pro::BuilderInfo::•((#C1) ?{core::String} "" : "ClearKeep", createEmptyInstance: #C8) in block {
+[@vm.inferred-type.metadata=protobuf::BuilderInfo?] static final field pro::BuilderInfo _i = let final pro::BuilderInfo #t5 = new pro::BuilderInfo::•((#C1) ?{core::String} "" : "ClearKeep", createEmptyInstance: #C6) in block {
[@vm.direct-call.metadata=protobuf::BuilderInfo.add] [@vm.inferred-type.metadata=!? (skip check)] #t5.{pro::BuilderInfo::add}<Null>(0, null, null, null, null, null, null);
[@vm.direct-call.metadata=protobuf::BuilderInfo.hasRequiredFields] [@vm.inferred-type.metadata=!? (skip check)] #t5.{pro::BuilderInfo::hasRequiredFields} = false;
} =>#t5;
@@ -108,7 +108,7 @@
;
[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:1] get info_() → pro::BuilderInfo
return [@vm.inferred-type.metadata=protobuf::BuilderInfo?] self::ClearKeep::_i;
- @#C12
+ @#C9
static method create() → self::ClearKeep
return new self::ClearKeep::_();
}
diff --git a/pkg/vm/testcases/transformations/type_flow/transformer/protobuf_handler/lib/encode_all_fields.dart.expect b/pkg/vm/testcases/transformations/type_flow/transformer/protobuf_handler/lib/encode_all_fields.dart.expect
index 09a43b0..4980123 100644
--- a/pkg/vm/testcases/transformations/type_flow/transformer/protobuf_handler/lib/encode_all_fields.dart.expect
+++ b/pkg/vm/testcases/transformations/type_flow/transformer/protobuf_handler/lib/encode_all_fields.dart.expect
@@ -45,11 +45,11 @@
[@vm.inferred-type.metadata=protobuf::BuilderInfo?] static final field pro::BuilderInfo _i = let final pro::BuilderInfo #t1 = new pro::BuilderInfo::•((#C1) ?{core::String} "" : "FooKeep") in block {
[@vm.direct-call.metadata=protobuf::BuilderInfo.aOM] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pro::BuilderInfo::aOM}<self::BarKeep>(1, (#C1) ?{core::String} "" : "barKeep", "barKeep", #C2);
[@vm.direct-call.metadata=protobuf::BuilderInfo.add] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pro::BuilderInfo::add}<Null>(0, null, null, null, null, null, null);
- [@vm.direct-call.metadata=protobuf::BuilderInfo.m] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pro::BuilderInfo::m}<core::String, self::BarKeep>(3, (#C1) ?{core::String} "" : "mapKeep", "FooKeep.MapKeepEntry", #C3, "mapKeep", #C2, #C4);
- [@vm.direct-call.metadata=protobuf::BuilderInfo.m] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pro::BuilderInfo::m}<core::String, self::ZopDrop>(4, (#C1) ?{core::String} "" : "mapDrop", "FooKeep.MapDropEntry", #C3, "mapDrop", #C5, #C4);
- [@vm.direct-call.metadata=protobuf::BuilderInfo.a] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pro::BuilderInfo::a}<core::int>(5, (#C1) ?{core::String} "" : "aKeep", #C6, "aKeep");
- [@vm.direct-call.metadata=protobuf::BuilderInfo.aOM] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pro::BuilderInfo::aOM}<self::HasKeep>(6, (#C1) ?{core::String} "" : "hasKeep", "hasKeep", #C7);
- [@vm.direct-call.metadata=protobuf::BuilderInfo.aOM] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pro::BuilderInfo::aOM}<self::ClearKeep>(7, (#C1) ?{core::String} "" : "clearKeep", "clearKeep", #C8);
+ [@vm.direct-call.metadata=protobuf::BuilderInfo.m] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pro::BuilderInfo::m}<core::String, self::BarKeep>(3, (#C1) ?{core::String} "" : "mapKeep", "FooKeep.MapKeepEntry", "mapKeep", #C2);
+ [@vm.direct-call.metadata=protobuf::BuilderInfo.m] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pro::BuilderInfo::m}<core::String, self::ZopDrop>(4, (#C1) ?{core::String} "" : "mapDrop", "FooKeep.MapDropEntry", "mapDrop", #C3);
+ [@vm.direct-call.metadata=protobuf::BuilderInfo.a] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pro::BuilderInfo::a}<core::int>(5, (#C1) ?{core::String} "" : "aKeep", #C4, "aKeep");
+ [@vm.direct-call.metadata=protobuf::BuilderInfo.aOM] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pro::BuilderInfo::aOM}<self::HasKeep>(6, (#C1) ?{core::String} "" : "hasKeep", "hasKeep", #C5);
+ [@vm.direct-call.metadata=protobuf::BuilderInfo.aOM] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pro::BuilderInfo::aOM}<self::ClearKeep>(7, (#C1) ?{core::String} "" : "clearKeep", "clearKeep", #C6);
[@vm.direct-call.metadata=protobuf::BuilderInfo.hasRequiredFields] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pro::BuilderInfo::hasRequiredFields} = false;
} =>#t1;
constructor _() → self::FooKeep
@@ -59,36 +59,36 @@
return [@vm.inferred-type.metadata=foo.pb.dart::FooKeep] self::FooKeep::create();
[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:1] get info_() → pro::BuilderInfo
return [@vm.inferred-type.metadata=protobuf::BuilderInfo?] self::FooKeep::_i;
- @#C11
+ @#C9
static method create() → self::FooKeep
return new self::FooKeep::_();
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:2] @#C13
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:2] @#C11
set barKeep([@vm.inferred-type.metadata=foo.pb.dart::BarKeep] self::BarKeep v) → void {
[@vm.direct-call.metadata=protobuf::GeneratedMessage.setField] [@vm.inferred-type.metadata=!? (skip check)] this.{pro::GeneratedMessage::setField}(1, v);
}
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:3] @#C15
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:3] @#C13
get mapKeep() → core::Map<core::String, self::BarKeep>
return [@vm.direct-call.metadata=protobuf::GeneratedMessage.$_getMap] [@vm.inferred-type.metadata=! (skip check)] this.{pro::GeneratedMessage::$_getMap}<core::String, self::BarKeep>(2);
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:4] @#C17
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:4] @#C15
get mapDrop() → core::Map<core::String, self::ZopDrop>
return [@vm.direct-call.metadata=protobuf::GeneratedMessage.$_getMap] [@vm.inferred-type.metadata=! (skip check)] this.{pro::GeneratedMessage::$_getMap}<core::String, self::ZopDrop>(3);
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:5] [@vm.unboxing-info.metadata=(i)->b] @#C19
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:5] [@vm.unboxing-info.metadata=(i)->b] @#C17
set aKeep([@vm.inferred-type.metadata=dart.core::_Smi (value: 43)] core::int v) → void {
[@vm.direct-call.metadata=protobuf::GeneratedMessage.$_setSignedInt32] [@vm.inferred-type.metadata=!? (skip check)] this.{pro::GeneratedMessage::$_setSignedInt32}(4, v);
}
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:6] @#C21
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:6] @#C19
set hasKeep([@vm.inferred-type.metadata=foo.pb.dart::HasKeep] self::HasKeep v) → void {
[@vm.direct-call.metadata=protobuf::GeneratedMessage.setField] [@vm.inferred-type.metadata=!? (skip check)] this.{pro::GeneratedMessage::setField}(6, v);
}
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:7] @#C23
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:7] @#C21
set clearKeep([@vm.inferred-type.metadata=foo.pb.dart::ClearKeep] self::ClearKeep v) → void {
[@vm.direct-call.metadata=protobuf::GeneratedMessage.setField] [@vm.inferred-type.metadata=!? (skip check)] this.{pro::GeneratedMessage::setField}(7, v);
}
}
class BarKeep extends pro::GeneratedMessage {
[@vm.inferred-type.metadata=protobuf::BuilderInfo?] static final field pro::BuilderInfo _i = let final pro::BuilderInfo #t2 = new pro::BuilderInfo::•((#C1) ?{core::String} "" : "BarKeep") in block {
- [@vm.direct-call.metadata=protobuf::BuilderInfo.a] [@vm.inferred-type.metadata=!? (skip check)] #t2.{pro::BuilderInfo::a}<core::int>(1, (#C1) ?{core::String} "" : "aKeep", #C6, "aKeep");
- [@vm.direct-call.metadata=protobuf::BuilderInfo.a] [@vm.inferred-type.metadata=!? (skip check)] #t2.{pro::BuilderInfo::a}<core::int>(2, (#C1) ?{core::String} "" : "bDrop", #C6, "bDrop");
+ [@vm.direct-call.metadata=protobuf::BuilderInfo.a] [@vm.inferred-type.metadata=!? (skip check)] #t2.{pro::BuilderInfo::a}<core::int>(1, (#C1) ?{core::String} "" : "aKeep", #C4, "aKeep");
+ [@vm.direct-call.metadata=protobuf::BuilderInfo.a] [@vm.inferred-type.metadata=!? (skip check)] #t2.{pro::BuilderInfo::a}<core::int>(2, (#C1) ?{core::String} "" : "bDrop", #C4, "bDrop");
[@vm.direct-call.metadata=protobuf::BuilderInfo.hasRequiredFields] [@vm.inferred-type.metadata=!? (skip check)] #t2.{pro::BuilderInfo::hasRequiredFields} = false;
} =>#t2;
constructor _() → self::BarKeep
@@ -98,14 +98,14 @@
return [@vm.inferred-type.metadata=foo.pb.dart::BarKeep] self::BarKeep::create();
[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:1] get info_() → pro::BuilderInfo
return [@vm.inferred-type.metadata=protobuf::BuilderInfo?] self::BarKeep::_i;
- @#C11
+ @#C9
static method create() → self::BarKeep
return new self::BarKeep::_();
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:8] [@vm.unboxing-info.metadata=(i)->b] @#C13
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:8] [@vm.unboxing-info.metadata=(i)->b] @#C11
set aKeep([@vm.inferred-type.metadata=dart.core::_Smi] core::int v) → void {
[@vm.direct-call.metadata=protobuf::GeneratedMessage.$_setSignedInt32] [@vm.inferred-type.metadata=!? (skip check)] this.{pro::GeneratedMessage::$_setSignedInt32}(0, v);
}
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:9] [@vm.unboxing-info.metadata=(i)->b] @#C25
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:9] [@vm.unboxing-info.metadata=(i)->b] @#C23
set bDrop([@vm.inferred-type.metadata=dart.core::_Smi (value: 4)] core::int v) → void {
[@vm.direct-call.metadata=protobuf::GeneratedMessage.$_setSignedInt32] [@vm.inferred-type.metadata=!? (skip check)] this.{pro::GeneratedMessage::$_setSignedInt32}(1, v);
}
@@ -122,7 +122,7 @@
return [@vm.inferred-type.metadata=foo.pb.dart::HasKeep] self::HasKeep::create();
[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:1] get info_() → pro::BuilderInfo
return [@vm.inferred-type.metadata=protobuf::BuilderInfo?] self::HasKeep::_i;
- @#C11
+ @#C9
static method create() → self::HasKeep
return new self::HasKeep::_();
}
@@ -138,13 +138,13 @@
return [@vm.inferred-type.metadata=foo.pb.dart::ClearKeep] self::ClearKeep::create();
[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:1] get info_() → pro::BuilderInfo
return [@vm.inferred-type.metadata=protobuf::BuilderInfo?] self::ClearKeep::_i;
- @#C11
+ @#C9
static method create() → self::ClearKeep
return new self::ClearKeep::_();
}
class ZopDrop extends pro::GeneratedMessage {
[@vm.inferred-type.metadata=protobuf::BuilderInfo?] static final field pro::BuilderInfo _i = let final pro::BuilderInfo #t5 = new pro::BuilderInfo::•((#C1) ?{core::String} "" : "ZopDrop") in block {
- [@vm.direct-call.metadata=protobuf::BuilderInfo.a] [@vm.inferred-type.metadata=!? (skip check)] #t5.{pro::BuilderInfo::a}<core::int>(1, (#C1) ?{core::String} "" : "aDrop", #C6, "aDrop");
+ [@vm.direct-call.metadata=protobuf::BuilderInfo.a] [@vm.inferred-type.metadata=!? (skip check)] #t5.{pro::BuilderInfo::a}<core::int>(1, (#C1) ?{core::String} "" : "aDrop", #C4, "aDrop");
[@vm.direct-call.metadata=protobuf::BuilderInfo.hasRequiredFields] [@vm.inferred-type.metadata=!? (skip check)] #t5.{pro::BuilderInfo::hasRequiredFields} = false;
} =>#t5;
constructor _() → self::ZopDrop
@@ -154,10 +154,10 @@
return [@vm.inferred-type.metadata=foo.pb.dart::ZopDrop] self::ZopDrop::create();
[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:1] get info_() → pro::BuilderInfo
return [@vm.inferred-type.metadata=protobuf::BuilderInfo?] self::ZopDrop::_i;
- @#C11
+ @#C9
static method create() → self::ZopDrop
return new self::ZopDrop::_();
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:10] [@vm.unboxing-info.metadata=(i)->b] @#C13
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:10] [@vm.unboxing-info.metadata=(i)->b] @#C11
set aDrop([@vm.inferred-type.metadata=dart.core::_Smi (value: 3)] core::int v) → void {
[@vm.direct-call.metadata=protobuf::GeneratedMessage.$_setSignedInt32] [@vm.inferred-type.metadata=!? (skip check)] this.{pro::GeneratedMessage::$_setSignedInt32}(0, v);
}
diff --git a/pkg/vm/testcases/transformations/type_flow/transformer/protobuf_handler/lib/freeze_test.dart.expect b/pkg/vm/testcases/transformations/type_flow/transformer/protobuf_handler/lib/freeze_test.dart.expect
index 50cebc8..15a7ebf 100644
--- a/pkg/vm/testcases/transformations/type_flow/transformer/protobuf_handler/lib/freeze_test.dart.expect
+++ b/pkg/vm/testcases/transformations/type_flow/transformer/protobuf_handler/lib/freeze_test.dart.expect
@@ -6,7 +6,6 @@
import "package:protobuf/protobuf.dart" as pro;
import "package:test_api/src/frontend/expect.dart" as exp;
import "package:test_api/src/frontend/throws_matcher.dart" as thr;
-import "package:matcher/src/type_matcher.dart" as typ;
import "package:test/test.dart";
import "file:pkg/vm/testcases/transformations/type_flow/transformer/protobuf_handler/lib/generated/foo.pb.dart";
@@ -21,13 +20,13 @@
} =>#t3);
[@vm.direct-call.metadata=library file:pkg/vm/testcases/transformations/type_flow/transformer/protobuf_handler/lib/generated/foo.pb.dart::FooKeep.aKeep] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pb::FooKeep::aKeep} = 43;
} =>#t1;
- tes::test("Freezing a message works", () → Null {
+ tes::test(() → Null {
[@vm.direct-call.metadata=protobuf::GeneratedMessage.freeze] [@vm.inferred-type.metadata=!? (skip check)] foo.{pro::GeneratedMessage::freeze}();
exp::expect([@vm.direct-call.metadata=library file:pkg/vm/testcases/transformations/type_flow/transformer/protobuf_handler/lib/generated/foo.pb.dart::BarKeep.aKeep??] [@vm.inferred-type.metadata=int] [@vm.direct-call.metadata=library file:pkg/vm/testcases/transformations/type_flow/transformer/protobuf_handler/lib/generated/foo.pb.dart::FooKeep.barKeep] [@vm.inferred-type.metadata=library file:pkg/vm/testcases/transformations/type_flow/transformer/protobuf_handler/lib/generated/foo.pb.dart::BarKeep?] foo.{pb::FooKeep::barKeep}.{pb::BarKeep::aKeep}, 5);
exp::expect([@vm.direct-call.metadata=library file:pkg/vm/testcases/transformations/type_flow/transformer/protobuf_handler/lib/generated/foo.pb.dart::BarKeep.aKeep??] [@vm.inferred-type.metadata=int] [@vm.inferred-type.metadata=library file:pkg/vm/testcases/transformations/type_flow/transformer/protobuf_handler/lib/generated/foo.pb.dart::BarKeep?] [@vm.direct-call.metadata=library file:pkg/vm/testcases/transformations/type_flow/transformer/protobuf_handler/lib/generated/foo.pb.dart::FooKeep.mapKeep] [@vm.inferred-type.metadata=!] foo.{pb::FooKeep::mapKeep}.{core::Map::[]}("foo").{pb::BarKeep::aKeep}, 2);
exp::expect([@vm.direct-call.metadata=library file:pkg/vm/testcases/transformations/type_flow/transformer/protobuf_handler/lib/generated/foo.pb.dart::FooKeep.hasHasKeep] [@vm.inferred-type.metadata=dart.core::bool (skip check)] foo.{pb::FooKeep::hasHasKeep}(), false);
exp::expect([@vm.direct-call.metadata=library file:pkg/vm/testcases/transformations/type_flow/transformer/protobuf_handler/lib/generated/foo.pb.dart::FooKeep.aKeep] [@vm.inferred-type.metadata=int] foo.{pb::FooKeep::aKeep}, 43);
- exp::expect(() → void => [@vm.direct-call.metadata=library file:pkg/vm/testcases/transformations/type_flow/transformer/protobuf_handler/lib/generated/foo.pb.dart::FooKeep.clearClearKeep] [@vm.inferred-type.metadata=!? (skip check)] foo.{pb::FooKeep::clearClearKeep}(), [@vm.inferred-type.metadata=library package:test_api/src/frontend/throws_matcher.dart::Throws] thr::throwsA(#C2));
+ exp::expect(() → void => [@vm.direct-call.metadata=library file:pkg/vm/testcases/transformations/type_flow/transformer/protobuf_handler/lib/generated/foo.pb.dart::FooKeep.clearClearKeep] [@vm.inferred-type.metadata=!? (skip check)] foo.{pb::FooKeep::clearClearKeep}(), [@vm.inferred-type.metadata=library package:test_api/src/frontend/throws_matcher.dart::Throws] thr::throwsA());
});
}
library foo.pb.dart /*isNonNullableByDefault*/;
@@ -42,11 +41,11 @@
[@vm.inferred-type.metadata=protobuf::BuilderInfo?] static final field pro::BuilderInfo _i = let final pro::BuilderInfo #t1 = new pro::BuilderInfo::•((#C1) ?{core::String} "" : "FooKeep") in block {
[@vm.direct-call.metadata=protobuf::BuilderInfo.aOM] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pro::BuilderInfo::aOM}<self::BarKeep>(1, (#C1) ?{core::String} "" : "barKeep", "barKeep", #C2);
[@vm.direct-call.metadata=protobuf::BuilderInfo.add] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pro::BuilderInfo::add}<Null>(0, null, null, null, null, null, null);
- [@vm.direct-call.metadata=protobuf::BuilderInfo.m] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pro::BuilderInfo::m}<core::String, self::BarKeep>(3, (#C1) ?{core::String} "" : "mapKeep", "FooKeep.MapKeepEntry", #C3, "mapKeep", #C2, #C4);
+ [@vm.direct-call.metadata=protobuf::BuilderInfo.m] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pro::BuilderInfo::m}<core::String, self::BarKeep>(3, (#C1) ?{core::String} "" : "mapKeep", #C2);
[@vm.direct-call.metadata=protobuf::BuilderInfo.add] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pro::BuilderInfo::add}<Null>(0, null, null, null, null, null, null);
- [@vm.direct-call.metadata=protobuf::BuilderInfo.a] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pro::BuilderInfo::a}<core::int>(5, (#C1) ?{core::String} "" : "aKeep", #C5, "aKeep");
- [@vm.direct-call.metadata=protobuf::BuilderInfo.aOM] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pro::BuilderInfo::aOM}<self::HasKeep>(6, (#C1) ?{core::String} "" : "hasKeep", "hasKeep", #C6);
- [@vm.direct-call.metadata=protobuf::BuilderInfo.aOM] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pro::BuilderInfo::aOM}<self::ClearKeep>(7, (#C1) ?{core::String} "" : "clearKeep", "clearKeep", #C7);
+ [@vm.direct-call.metadata=protobuf::BuilderInfo.a] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pro::BuilderInfo::a}<core::int>(5, (#C1) ?{core::String} "" : "aKeep", #C3);
+ [@vm.direct-call.metadata=protobuf::BuilderInfo.aOM] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pro::BuilderInfo::aOM}<self::HasKeep>(6, (#C1) ?{core::String} "" : "hasKeep", "hasKeep", #C4);
+ [@vm.direct-call.metadata=protobuf::BuilderInfo.aOM] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pro::BuilderInfo::aOM}<self::ClearKeep>(7, (#C1) ?{core::String} "" : "clearKeep", "clearKeep", #C5);
[@vm.direct-call.metadata=protobuf::BuilderInfo.hasRequiredFields] [@vm.inferred-type.metadata=!? (skip check)] #t1.{pro::BuilderInfo::hasRequiredFields} = false;
} =>#t1;
constructor _() → self::FooKeep
@@ -56,36 +55,36 @@
return [@vm.inferred-type.metadata=foo.pb.dart::FooKeep] self::FooKeep::create();
[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:1] get info_() → pro::BuilderInfo
return [@vm.inferred-type.metadata=protobuf::BuilderInfo?] self::FooKeep::_i;
- @#C10
+ @#C8
static method create() → self::FooKeep
return new self::FooKeep::_();
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:2,getterSelectorId:3] @#C12
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:2,getterSelectorId:3] @#C10
get barKeep() → self::BarKeep
- return [@vm.direct-call.metadata=protobuf::GeneratedMessage.$_getN] [@vm.inferred-type.metadata=foo.pb.dart::BarKeep? (skip check)] this.{pro::GeneratedMessage::$_getN}<self::BarKeep>(0);
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:2,getterSelectorId:3] @#C12
+ return [@vm.direct-call.metadata=protobuf::GeneratedMessage.$_getN] [@vm.inferred-type.metadata=foo.pb.dart::BarKeep? (skip check)] this.{pro::GeneratedMessage::$_getN}<self::BarKeep>();
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:2,getterSelectorId:3] @#C10
set barKeep([@vm.inferred-type.metadata=foo.pb.dart::BarKeep] self::BarKeep v) → void {
- [@vm.direct-call.metadata=protobuf::GeneratedMessage.setField] [@vm.inferred-type.metadata=!? (skip check)] this.{pro::GeneratedMessage::setField}(1, v);
+ [@vm.direct-call.metadata=protobuf::GeneratedMessage.setField] [@vm.inferred-type.metadata=!? (skip check)] this.{pro::GeneratedMessage::setField}(v);
}
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:4] @#C14
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:4] @#C12
get mapKeep() → core::Map<core::String, self::BarKeep>
- return [@vm.direct-call.metadata=protobuf::GeneratedMessage.$_getMap] [@vm.inferred-type.metadata=! (skip check)] this.{pro::GeneratedMessage::$_getMap}<core::String, self::BarKeep>(2);
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:5,getterSelectorId:6] [@vm.unboxing-info.metadata=()->i] @#C16
+ return [@vm.direct-call.metadata=protobuf::GeneratedMessage.$_getMap] [@vm.inferred-type.metadata=! (skip check)] this.{pro::GeneratedMessage::$_getMap}<core::String, self::BarKeep>();
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:5,getterSelectorId:6] [@vm.unboxing-info.metadata=()->i] @#C14
get aKeep() → core::int
return [@vm.direct-call.metadata=protobuf::GeneratedMessage.$_getIZ] [@vm.inferred-type.metadata=int (skip check)] this.{pro::GeneratedMessage::$_getIZ}(4);
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:5,getterSelectorId:6] [@vm.unboxing-info.metadata=(i)->b] @#C16
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:5,getterSelectorId:6] [@vm.unboxing-info.metadata=(i)->b] @#C14
set aKeep([@vm.inferred-type.metadata=dart.core::_Smi (value: 43)] core::int v) → void {
[@vm.direct-call.metadata=protobuf::GeneratedMessage.$_setSignedInt32] [@vm.inferred-type.metadata=!? (skip check)] this.{pro::GeneratedMessage::$_setSignedInt32}(4, v);
}
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:7,getterSelectorId:8] @#C18
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:7,getterSelectorId:8] @#C16
method hasHasKeep() → core::bool
- return [@vm.direct-call.metadata=protobuf::GeneratedMessage.$_has] [@vm.inferred-type.metadata=dart.core::bool (skip check)] this.{pro::GeneratedMessage::$_has}(5);
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:9,getterSelectorId:10] @#C20
+ return [@vm.direct-call.metadata=protobuf::GeneratedMessage.$_has] [@vm.inferred-type.metadata=dart.core::bool (skip check)] this.{pro::GeneratedMessage::$_has}();
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:9,getterSelectorId:10] @#C18
method clearClearKeep() → void
- return [@vm.direct-call.metadata=protobuf::GeneratedMessage.clearField] [@vm.inferred-type.metadata=dart.core::Null? (skip check) (value: null)] this.{pro::GeneratedMessage::clearField}(7);
+ return [@vm.direct-call.metadata=protobuf::GeneratedMessage.clearField] [@vm.inferred-type.metadata=dart.core::Null? (skip check) (value: null)] this.{pro::GeneratedMessage::clearField}();
}
class BarKeep extends pro::GeneratedMessage {
[@vm.inferred-type.metadata=protobuf::BuilderInfo?] static final field pro::BuilderInfo _i = let final pro::BuilderInfo #t2 = new pro::BuilderInfo::•((#C1) ?{core::String} "" : "BarKeep") in block {
- [@vm.direct-call.metadata=protobuf::BuilderInfo.a] [@vm.inferred-type.metadata=!? (skip check)] #t2.{pro::BuilderInfo::a}<core::int>(1, (#C1) ?{core::String} "" : "aKeep", #C5, "aKeep");
+ [@vm.direct-call.metadata=protobuf::BuilderInfo.a] [@vm.inferred-type.metadata=!? (skip check)] #t2.{pro::BuilderInfo::a}<core::int>(1, (#C1) ?{core::String} "" : "aKeep", #C3);
[@vm.direct-call.metadata=protobuf::BuilderInfo.add] [@vm.inferred-type.metadata=!? (skip check)] #t2.{pro::BuilderInfo::add}<Null>(0, null, null, null, null, null, null);
[@vm.direct-call.metadata=protobuf::BuilderInfo.hasRequiredFields] [@vm.inferred-type.metadata=!? (skip check)] #t2.{pro::BuilderInfo::hasRequiredFields} = false;
} =>#t2;
@@ -96,13 +95,13 @@
return [@vm.inferred-type.metadata=foo.pb.dart::BarKeep] self::BarKeep::create();
[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:1] get info_() → pro::BuilderInfo
return [@vm.inferred-type.metadata=protobuf::BuilderInfo?] self::BarKeep::_i;
- @#C10
+ @#C8
static method create() → self::BarKeep
return new self::BarKeep::_();
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:11,getterSelectorId:12] [@vm.unboxing-info.metadata=()->i] @#C12
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:11,getterSelectorId:12] [@vm.unboxing-info.metadata=()->i] @#C10
get aKeep() → core::int
return [@vm.direct-call.metadata=protobuf::GeneratedMessage.$_getIZ] [@vm.inferred-type.metadata=int (skip check)] this.{pro::GeneratedMessage::$_getIZ}(0);
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:11,getterSelectorId:12] [@vm.unboxing-info.metadata=(i)->b] @#C12
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:11,getterSelectorId:12] [@vm.unboxing-info.metadata=(i)->b] @#C10
set aKeep([@vm.inferred-type.metadata=dart.core::_Smi] core::int v) → void {
[@vm.direct-call.metadata=protobuf::GeneratedMessage.$_setSignedInt32] [@vm.inferred-type.metadata=!? (skip check)] this.{pro::GeneratedMessage::$_setSignedInt32}(0, v);
}
@@ -117,7 +116,7 @@
;
[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:1] get info_() → pro::BuilderInfo
return [@vm.inferred-type.metadata=protobuf::BuilderInfo?] self::HasKeep::_i;
- @#C10
+ @#C8
static method create() → self::HasKeep
return new self::HasKeep::_();
}
@@ -131,7 +130,7 @@
;
[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:1] get info_() → pro::BuilderInfo
return [@vm.inferred-type.metadata=protobuf::BuilderInfo?] self::ClearKeep::_i;
- @#C10
+ @#C8
static method create() → self::ClearKeep
return new self::ClearKeep::_();
}
diff --git a/pkg/vm/testcases/transformations/type_flow/transformer/protobuf_handler/lib/name_mangling_test.dart.expect b/pkg/vm/testcases/transformations/type_flow/transformer/protobuf_handler/lib/name_mangling_test.dart.expect
index 7f311bf..6f760ed 100644
--- a/pkg/vm/testcases/transformations/type_flow/transformer/protobuf_handler/lib/name_mangling_test.dart.expect
+++ b/pkg/vm/testcases/transformations/type_flow/transformer/protobuf_handler/lib/name_mangling_test.dart.expect
@@ -43,14 +43,14 @@
;
static factory fromBuffer([@vm.inferred-type.metadata=dart.core::_GrowableList<dart.core::int*>] core::List<core::int> i) → self::NameManglingKeep
return let final self::NameManglingKeep #t3 = [@vm.inferred-type.metadata=name_mangling.pb.dart::NameManglingKeep] self::NameManglingKeep::create() in block {
- [@vm.direct-call.metadata=protobuf::GeneratedMessage.mergeFromBuffer] [@vm.inferred-type.metadata=!? (skip check)] #t3.{pro::GeneratedMessage::mergeFromBuffer}(i, #C7);
+ [@vm.direct-call.metadata=protobuf::GeneratedMessage.mergeFromBuffer] [@vm.inferred-type.metadata=!? (skip check)] #t3.{pro::GeneratedMessage::mergeFromBuffer}(i);
} =>#t3;
[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:1] get info_() → pro::BuilderInfo
return [@vm.inferred-type.metadata=protobuf::BuilderInfo?] self::NameManglingKeep::_i;
@#C5
static method create() → self::NameManglingKeep
return new self::NameManglingKeep::_();
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:2,getterSelectorId:3] @#C9
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:2,getterSelectorId:3] @#C8
method hasClone_10() → core::bool
- return [@vm.direct-call.metadata=protobuf::GeneratedMessage.$_has] [@vm.inferred-type.metadata=dart.core::bool (skip check)] this.{pro::GeneratedMessage::$_has}(0);
+ return [@vm.direct-call.metadata=protobuf::GeneratedMessage.$_has] [@vm.inferred-type.metadata=dart.core::bool (skip check)] this.{pro::GeneratedMessage::$_has}();
}
diff --git a/pkg/vm/testcases/transformations/type_flow/transformer/type_cast_elimination.dart.expect b/pkg/vm/testcases/transformations/type_flow/transformer/type_cast_elimination.dart.expect
index 101cd55..72a2ae0 100644
--- a/pkg/vm/testcases/transformations/type_flow/transformer/type_cast_elimination.dart.expect
+++ b/pkg/vm/testcases/transformations/type_flow/transformer/type_cast_elimination.dart.expect
@@ -12,8 +12,8 @@
synthetic constructor •() → self::B<self::B::T*>*
: super self::A::•()
;
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:1,getterSelectorId:2] [@vm.unboxing-info.metadata=(i)->i] method testT1([@vm.inferred-type.metadata=dart.core::_Smi (value: 42)] dynamic x) → dynamic
- return _in::unsafeCast<self::B::T*>(x);
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:1,getterSelectorId:2] [@vm.unboxing-info.metadata=()->i] method testT1() → dynamic
+ return _in::unsafeCast<self::B::T*>(#C1);
[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:3,getterSelectorId:4] method testT2negative([@vm.inferred-type.metadata=#lib::A<dart.core::String*>] dynamic x) → dynamic
return x as self::B::T*;
[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:5,getterSelectorId:6] method testAOfT1([@vm.inferred-type.metadata=#lib::A<#lib::A<dart.core::int*>*>] dynamic x) → dynamic
@@ -21,14 +21,14 @@
[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:7,getterSelectorId:8] method testAOfT2negative([@vm.inferred-type.metadata=#lib::A<#lib::A<dart.core::num*>*>] dynamic x) → dynamic
return x as self::A<self::B::T*>*;
}
-[@vm.unboxing-info.metadata=(i)->i]static method testInt1([@vm.inferred-type.metadata=dart.core::_Smi (value: 42)] dynamic x) → dynamic
- return _in::unsafeCast<core::int*>(x);
-static method testInt2([@vm.inferred-type.metadata=dart.core::Null? (value: null)] dynamic x) → dynamic
- return _in::unsafeCast<core::int*>(x);
-static method testDynamic([@vm.inferred-type.metadata=dart.core::_OneByteString (value: "hi")] dynamic x) → dynamic
- return _in::unsafeCast<dynamic>(x);
-static method testObject([@vm.inferred-type.metadata=dart.core::_OneByteString (value: "bye")] dynamic x) → dynamic
- return x;
+[@vm.unboxing-info.metadata=()->i]static method testInt1() → dynamic
+ return _in::unsafeCast<core::int*>(#C1);
+static method testInt2() → dynamic
+ return _in::unsafeCast<core::int*>(#C2);
+static method testDynamic() → dynamic
+ return _in::unsafeCast<dynamic>(#C3);
+static method testObject() → dynamic
+ return #C4;
static method testBOfInt([@vm.inferred-type.metadata=#lib::B<dart.core::int*>] dynamic x) → dynamic
return _in::unsafeCast<self::B<core::int*>*>(x);
static method testAOfInt([@vm.inferred-type.metadata=#lib::B<dart.core::int*>] dynamic x) → dynamic
@@ -40,16 +40,16 @@
static method testAOfAOfB2negative([@vm.inferred-type.metadata=#lib::A<#lib::A<#lib::A<dynamic>*>*>] dynamic x) → dynamic
return x as self::A<self::A<self::B<dynamic>*>*>*;
static method main() → void {
- self::testInt1(42);
- self::testInt2(null);
- self::testDynamic("hi");
- self::testObject("bye");
+ self::testInt1();
+ self::testInt2();
+ self::testDynamic();
+ self::testObject();
self::testBOfInt(new self::B::•<core::int*>());
self::testAOfInt(new self::B::•<core::int*>());
self::testAOfNum(new self::B::•<core::int*>());
self::testAOfAOfB1(new self::A::•<self::A<self::B<dynamic>*>*>());
self::testAOfAOfB2negative(new self::A::•<self::A<self::A<dynamic>*>*>());
- [@vm.direct-call.metadata=#lib::B.testT1] [@vm.inferred-type.metadata=!? (skip check)] new self::B::•<core::int*>().{self::B::testT1}(42);
+ [@vm.direct-call.metadata=#lib::B.testT1] [@vm.inferred-type.metadata=!? (skip check)] new self::B::•<core::int*>().{self::B::testT1}();
[@vm.direct-call.metadata=#lib::B.testT2negative] [@vm.inferred-type.metadata=!? (skip check)] new self::B::•<self::A<core::int*>*>().{self::B::testT2negative}(new self::A::•<core::String*>());
[@vm.direct-call.metadata=#lib::B.testAOfT1] [@vm.inferred-type.metadata=!? (skip check)] new self::B::•<self::A<core::int*>*>().{self::B::testAOfT1}(new self::A::•<self::A<core::int*>*>());
[@vm.direct-call.metadata=#lib::B.testAOfT2negative] [@vm.inferred-type.metadata=!? (skip check)] new self::B::•<self::A<core::int*>*>().{self::B::testAOfT2negative}(new self::A::•<self::A<core::num*>*>());
diff --git a/pkg/vm/testcases/transformations/type_flow/transformer/type_cast_elimination_nnbd.dart.expect b/pkg/vm/testcases/transformations/type_flow/transformer/type_cast_elimination_nnbd.dart.expect
index 11d1e0b..95e736c 100644
--- a/pkg/vm/testcases/transformations/type_flow/transformer/type_cast_elimination_nnbd.dart.expect
+++ b/pkg/vm/testcases/transformations/type_flow/transformer/type_cast_elimination_nnbd.dart.expect
@@ -12,60 +12,60 @@
synthetic constructor •() → self::B<self::B::T%>
: super self::A::•()
;
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:1,getterSelectorId:2] [@vm.unboxing-info.metadata=(i)->i] method testT1([@vm.inferred-type.metadata=dart.core::_Smi (value: 42)] dynamic x) → dynamic
- return _in::unsafeCast<self::B::T%>(x);
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:3,getterSelectorId:4] method testT2([@vm.inferred-type.metadata=dart.core::Null? (value: null)] dynamic x) → dynamic
- return _in::unsafeCast<self::B::T%>(x);
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:5,getterSelectorId:6] method testT3([@vm.inferred-type.metadata=dart.core::Null? (value: null)] dynamic x) → dynamic
- return _in::unsafeCast<self::B::T%>(x);
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:7,getterSelectorId:8] [@vm.unboxing-info.metadata=(i)->i] method testNullableT1([@vm.inferred-type.metadata=dart.core::_Smi (value: 42)] dynamic x) → dynamic
- return _in::unsafeCast<self::B::T?>(x);
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:9,getterSelectorId:10] method testNullableT2([@vm.inferred-type.metadata=dart.core::Null? (value: null)] dynamic x) → dynamic
- return _in::unsafeCast<self::B::T?>(x);
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:1,getterSelectorId:2] [@vm.unboxing-info.metadata=()->i] method testT1() → dynamic
+ return _in::unsafeCast<self::B::T%>(#C1);
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:3,getterSelectorId:4] method testT2() → dynamic
+ return _in::unsafeCast<self::B::T%>(#C2);
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:5,getterSelectorId:6] method testT3() → dynamic
+ return _in::unsafeCast<self::B::T%>(#C2);
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:7,getterSelectorId:8] [@vm.unboxing-info.metadata=()->i] method testNullableT1() → dynamic
+ return _in::unsafeCast<self::B::T?>(#C1);
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:9,getterSelectorId:10] method testNullableT2() → dynamic
+ return _in::unsafeCast<self::B::T?>(#C2);
}
-[@vm.unboxing-info.metadata=(i)->i]static method testInt1([@vm.inferred-type.metadata=dart.core::_Smi (value: 42)] dynamic x) → dynamic
- return _in::unsafeCast<core::int>(x);
-static method testInt2([@vm.inferred-type.metadata=dart.core::Null? (value: null)] dynamic x) → dynamic
- return _in::unsafeCast<core::int>(x);
-[@vm.unboxing-info.metadata=(i)->i]static method testNullableInt1([@vm.inferred-type.metadata=dart.core::_Smi (value: 42)] dynamic x) → dynamic
- return _in::unsafeCast<core::int?>(x);
-static method testNullableInt2([@vm.inferred-type.metadata=dart.core::Null? (value: null)] dynamic x) → dynamic
- return _in::unsafeCast<core::int?>(x);
-static method testDynamic([@vm.inferred-type.metadata=dart.core::_OneByteString (value: "hi")] dynamic x) → dynamic
- return _in::unsafeCast<dynamic>(x);
-static method testObject([@vm.inferred-type.metadata=dart.core::Null? (value: null)] dynamic x) → dynamic
- return x;
-static method testNullableObject([@vm.inferred-type.metadata=dart.core::Null? (value: null)] dynamic x) → dynamic
- return x;
+[@vm.unboxing-info.metadata=()->i]static method testInt1() → dynamic
+ return _in::unsafeCast<core::int>(#C1);
+static method testInt2() → dynamic
+ return _in::unsafeCast<core::int>(#C2);
+[@vm.unboxing-info.metadata=()->i]static method testNullableInt1() → dynamic
+ return _in::unsafeCast<core::int?>(#C1);
+static method testNullableInt2() → dynamic
+ return _in::unsafeCast<core::int?>(#C2);
+static method testDynamic() → dynamic
+ return _in::unsafeCast<dynamic>(#C3);
+static method testObject() → dynamic
+ return #C2;
+static method testNullableObject() → dynamic
+ return #C2;
static method testAOfNum1([@vm.inferred-type.metadata=#lib::B<dart.core::int>] dynamic x) → dynamic
return _in::unsafeCast<self::A<core::num>>(x);
static method testAOfNum2([@vm.inferred-type.metadata=#lib::B<dart.core::int?>] dynamic x) → dynamic
return _in::unsafeCast<self::A<core::num>>(x);
-static method testAOfNum3([@vm.inferred-type.metadata=dart.core::Null? (value: null)] dynamic x) → dynamic
- return _in::unsafeCast<self::A<core::num>>(x);
+static method testAOfNum3() → dynamic
+ return _in::unsafeCast<self::A<core::num>>(#C2);
static method testAOfNullableNum([@vm.inferred-type.metadata=#lib::B<dart.core::int?>] dynamic x) → dynamic
return _in::unsafeCast<self::A<core::num?>>(x);
-static method testNullableAOfNum([@vm.inferred-type.metadata=dart.core::Null? (value: null)] dynamic x) → dynamic
- return _in::unsafeCast<self::A<core::num>?>(x);
+static method testNullableAOfNum() → dynamic
+ return _in::unsafeCast<self::A<core::num>?>(#C2);
static method testNullableAOfNullableNum([@vm.inferred-type.metadata=#lib::B<dart.core::int?>] dynamic x) → dynamic
return _in::unsafeCast<self::A<core::num?>?>(x);
static method main() → void {
- self::testInt1(42);
- self::testInt2(null);
- self::testNullableInt1(42);
- self::testNullableInt2(null);
- self::testDynamic("hi");
- self::testObject(null);
- self::testNullableObject(null);
+ self::testInt1();
+ self::testInt2();
+ self::testNullableInt1();
+ self::testNullableInt2();
+ self::testDynamic();
+ self::testObject();
+ self::testNullableObject();
self::testAOfNum1(new self::B::•<core::int>());
self::testAOfNum2(new self::B::•<core::int?>());
- self::testAOfNum3(null);
+ self::testAOfNum3();
self::testAOfNullableNum(new self::B::•<core::int?>());
- self::testNullableAOfNum(null);
+ self::testNullableAOfNum();
self::testNullableAOfNullableNum(new self::B::•<core::int?>());
- [@vm.direct-call.metadata=#lib::B.testT1] [@vm.inferred-type.metadata=!? (skip check)] new self::B::•<core::int>().{self::B::testT1}(42);
- [@vm.direct-call.metadata=#lib::B.testT2] [@vm.inferred-type.metadata=!? (skip check)] new self::B::•<core::int>().{self::B::testT2}(null);
- [@vm.direct-call.metadata=#lib::B.testT3] [@vm.inferred-type.metadata=!? (skip check)] new self::B::•<core::int?>().{self::B::testT3}(null);
- [@vm.direct-call.metadata=#lib::B.testNullableT1] [@vm.inferred-type.metadata=!? (skip check)] new self::B::•<core::int>().{self::B::testNullableT1}(42);
- [@vm.direct-call.metadata=#lib::B.testNullableT2] [@vm.inferred-type.metadata=!? (skip check)] new self::B::•<core::int>().{self::B::testNullableT2}(null);
+ [@vm.direct-call.metadata=#lib::B.testT1] [@vm.inferred-type.metadata=!? (skip check)] new self::B::•<core::int>().{self::B::testT1}();
+ [@vm.direct-call.metadata=#lib::B.testT2] [@vm.inferred-type.metadata=!? (skip check)] new self::B::•<core::int>().{self::B::testT2}();
+ [@vm.direct-call.metadata=#lib::B.testT3] [@vm.inferred-type.metadata=!? (skip check)] new self::B::•<core::int?>().{self::B::testT3}();
+ [@vm.direct-call.metadata=#lib::B.testNullableT1] [@vm.inferred-type.metadata=!? (skip check)] new self::B::•<core::int>().{self::B::testNullableT1}();
+ [@vm.direct-call.metadata=#lib::B.testNullableT2] [@vm.inferred-type.metadata=!? (skip check)] new self::B::•<core::int>().{self::B::testNullableT2}();
}
diff --git a/pkg/vm/testcases/transformations/type_flow/transformer/type_cast_elimination_nnbd_strong.dart.expect b/pkg/vm/testcases/transformations/type_flow/transformer/type_cast_elimination_nnbd_strong.dart.expect
index 10ac8a6..8ad5b44 100644
--- a/pkg/vm/testcases/transformations/type_flow/transformer/type_cast_elimination_nnbd_strong.dart.expect
+++ b/pkg/vm/testcases/transformations/type_flow/transformer/type_cast_elimination_nnbd_strong.dart.expect
@@ -12,63 +12,63 @@
synthetic constructor •() → self::B<self::B::T%>
: super self::A::•()
;
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:1,getterSelectorId:2] [@vm.unboxing-info.metadata=(i)->i] method testT1([@vm.inferred-type.metadata=dart.core::_Smi (value: 42)] dynamic x) → dynamic
- return _in::unsafeCast<self::B::T%>(x);
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:3,getterSelectorId:4] method testT2negative([@vm.inferred-type.metadata=dart.core::Null? (value: null)] dynamic x) → dynamic
- return x as{ForNonNullableByDefault} self::B::T%;
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:5,getterSelectorId:6] method testT3([@vm.inferred-type.metadata=dart.core::Null? (value: null)] dynamic x) → dynamic
- return _in::unsafeCast<self::B::T%>(x);
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:7,getterSelectorId:8] [@vm.unboxing-info.metadata=(i)->i] method testNullableT1([@vm.inferred-type.metadata=dart.core::_Smi (value: 42)] dynamic x) → dynamic
- return _in::unsafeCast<self::B::T?>(x);
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:9,getterSelectorId:10] method testNullableT2([@vm.inferred-type.metadata=dart.core::Null? (value: null)] dynamic x) → dynamic
- return _in::unsafeCast<self::B::T?>(x);
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:1,getterSelectorId:2] [@vm.unboxing-info.metadata=()->i] method testT1() → dynamic
+ return _in::unsafeCast<self::B::T%>(#C1);
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:3,getterSelectorId:4] method testT2negative() → dynamic
+ return (#C2) as{ForNonNullableByDefault} self::B::T%;
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:5,getterSelectorId:6] method testT3() → dynamic
+ return _in::unsafeCast<self::B::T%>(#C2);
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:7,getterSelectorId:8] [@vm.unboxing-info.metadata=()->i] method testNullableT1() → dynamic
+ return _in::unsafeCast<self::B::T?>(#C1);
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:9,getterSelectorId:10] method testNullableT2() → dynamic
+ return _in::unsafeCast<self::B::T?>(#C2);
}
-[@vm.unboxing-info.metadata=(i)->i]static method testInt1([@vm.inferred-type.metadata=dart.core::_Smi (value: 42)] dynamic x) → dynamic
- return _in::unsafeCast<core::int>(x);
-static method testInt2negative([@vm.inferred-type.metadata=dart.core::Null? (value: null)] dynamic x) → dynamic
- return x as{ForNonNullableByDefault} core::int;
-[@vm.unboxing-info.metadata=(i)->i]static method testNullableInt1([@vm.inferred-type.metadata=dart.core::_Smi (value: 42)] dynamic x) → dynamic
- return _in::unsafeCast<core::int?>(x);
-static method testNullableInt2([@vm.inferred-type.metadata=dart.core::Null? (value: null)] dynamic x) → dynamic
- return _in::unsafeCast<core::int?>(x);
-static method testDynamic([@vm.inferred-type.metadata=dart.core::_OneByteString (value: "hi")] dynamic x) → dynamic
- return _in::unsafeCast<dynamic>(x);
-static method testObjectNegative([@vm.inferred-type.metadata=dart.core::Null? (value: null)] dynamic x) → dynamic
- return let dynamic #t1 = x in true ?{core::Object} #t1 as{ForNonNullableByDefault} core::Object : #t1{core::Object};
-static method testNullableObject([@vm.inferred-type.metadata=dart.core::Null? (value: null)] dynamic x) → dynamic
- return x;
+[@vm.unboxing-info.metadata=()->i]static method testInt1() → dynamic
+ return _in::unsafeCast<core::int>(#C1);
+static method testInt2negative() → dynamic
+ return (#C2) as{ForNonNullableByDefault} core::int;
+[@vm.unboxing-info.metadata=()->i]static method testNullableInt1() → dynamic
+ return _in::unsafeCast<core::int?>(#C1);
+static method testNullableInt2() → dynamic
+ return _in::unsafeCast<core::int?>(#C2);
+static method testDynamic() → dynamic
+ return _in::unsafeCast<dynamic>(#C3);
+static method testObjectNegative() → dynamic
+ return let dynamic #t1 = #C2 in true ?{core::Object} #t1 as{ForNonNullableByDefault} core::Object : #t1{core::Object};
+static method testNullableObject() → dynamic
+ return #C2;
static method testAOfNum1([@vm.inferred-type.metadata=#lib::B<dart.core::int>] dynamic x) → dynamic
return _in::unsafeCast<self::A<core::num>>(x);
static method testAOfNum2negative([@vm.inferred-type.metadata=#lib::B<dart.core::int?>] dynamic x) → dynamic
return x as{ForNonNullableByDefault} self::A<core::num>;
-static method testAOfNum3negative([@vm.inferred-type.metadata=dart.core::Null? (value: null)] dynamic x) → dynamic
- return x as{ForNonNullableByDefault} self::A<core::num>;
+static method testAOfNum3negative() → dynamic
+ return (#C2) as{ForNonNullableByDefault} self::A<core::num>;
static method testAOfNullableNum([@vm.inferred-type.metadata=#lib::B<dart.core::int?>] dynamic x) → dynamic
return _in::unsafeCast<self::A<core::num?>>(x);
-static method testNullableAOfNum([@vm.inferred-type.metadata=dart.core::Null? (value: null)] dynamic x) → dynamic
- return _in::unsafeCast<self::A<core::num>?>(x);
+static method testNullableAOfNum() → dynamic
+ return _in::unsafeCast<self::A<core::num>?>(#C2);
static method testNullableAOfNumNegative([@vm.inferred-type.metadata=#lib::B<dart.core::int?>] dynamic x) → dynamic
return x as{ForNonNullableByDefault} self::A<core::num>?;
static method testNullableAOfNullableNum([@vm.inferred-type.metadata=#lib::B<dart.core::int?>] dynamic x) → dynamic
return _in::unsafeCast<self::A<core::num?>?>(x);
static method main() → void {
- self::testInt1(42);
- self::testInt2negative(null);
- self::testNullableInt1(42);
- self::testNullableInt2(null);
- self::testDynamic("hi");
- self::testObjectNegative(null);
- self::testNullableObject(null);
+ self::testInt1();
+ self::testInt2negative();
+ self::testNullableInt1();
+ self::testNullableInt2();
+ self::testDynamic();
+ self::testObjectNegative();
+ self::testNullableObject();
self::testAOfNum1(new self::B::•<core::int>());
self::testAOfNum2negative(new self::B::•<core::int?>());
- self::testAOfNum3negative(null);
+ self::testAOfNum3negative();
self::testAOfNullableNum(new self::B::•<core::int?>());
- self::testNullableAOfNum(null);
+ self::testNullableAOfNum();
self::testNullableAOfNumNegative(new self::B::•<core::int?>());
self::testNullableAOfNullableNum(new self::B::•<core::int?>());
- [@vm.direct-call.metadata=#lib::B.testT1] [@vm.inferred-type.metadata=!? (skip check)] new self::B::•<core::int>().{self::B::testT1}(42);
- [@vm.direct-call.metadata=#lib::B.testT2negative] [@vm.inferred-type.metadata=!? (skip check)] new self::B::•<core::int>().{self::B::testT2negative}(null);
- [@vm.direct-call.metadata=#lib::B.testT3] [@vm.inferred-type.metadata=!? (skip check)] new self::B::•<core::int?>().{self::B::testT3}(null);
- [@vm.direct-call.metadata=#lib::B.testNullableT1] [@vm.inferred-type.metadata=!? (skip check)] new self::B::•<core::int>().{self::B::testNullableT1}(42);
- [@vm.direct-call.metadata=#lib::B.testNullableT2] [@vm.inferred-type.metadata=!? (skip check)] new self::B::•<core::int>().{self::B::testNullableT2}(null);
+ [@vm.direct-call.metadata=#lib::B.testT1] [@vm.inferred-type.metadata=!? (skip check)] new self::B::•<core::int>().{self::B::testT1}();
+ [@vm.direct-call.metadata=#lib::B.testT2negative] [@vm.inferred-type.metadata=!? (skip check)] new self::B::•<core::int>().{self::B::testT2negative}();
+ [@vm.direct-call.metadata=#lib::B.testT3] [@vm.inferred-type.metadata=!? (skip check)] new self::B::•<core::int?>().{self::B::testT3}();
+ [@vm.direct-call.metadata=#lib::B.testNullableT1] [@vm.inferred-type.metadata=!? (skip check)] new self::B::•<core::int>().{self::B::testNullableT1}();
+ [@vm.direct-call.metadata=#lib::B.testNullableT2] [@vm.inferred-type.metadata=!? (skip check)] new self::B::•<core::int>().{self::B::testNullableT2}();
}
diff --git a/pkg/vm/testcases/transformations/type_flow/transformer/unboxed_getters.dart.expect b/pkg/vm/testcases/transformations/type_flow/transformer/unboxed_getters.dart.expect
index 4dbd258..2109c6a 100644
--- a/pkg/vm/testcases/transformations/type_flow/transformer/unboxed_getters.dart.expect
+++ b/pkg/vm/testcases/transformations/type_flow/transformer/unboxed_getters.dart.expect
@@ -23,8 +23,8 @@
}
class BI2A extends core::Object implements self::BI2 {
[@vm.inferred-type.metadata=dart.core::Null? (value: null)] [@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,getterSelectorId:2] final field core::int* value;
- constructor •([@vm.inferred-type.metadata=dart.core::Null? (value: null)] core::int* value) → self::BI2A*
- : self::BI2A::value = value, super core::Object::•()
+ constructor •() → self::BI2A*
+ : self::BI2A::value = #C1, super core::Object::•()
;
}
class BI2B extends core::Object implements self::BI2 {
@@ -81,7 +81,7 @@
final self::BI1A* bi1a = new self::BI1A::•([@vm.inferred-type.metadata=int] self::smiOrMint);
final self::BI1B* bi1b = new self::BI1B::•();
self::use([@vm.inferred-type.metadata=int?]([@vm.inferred-type.metadata=dart.core::bool?] self::kTrue ?{self::BI1*} bi1a : bi1b).{self::BI1::value});
- final self::BI2A* bi2a = new self::BI2A::•(null);
+ final self::BI2A* bi2a = new self::BI2A::•();
final self::BI2B* bi2b = new self::BI2B::•();
self::use([@vm.inferred-type.metadata=int?]([@vm.inferred-type.metadata=dart.core::bool?] self::kTrue ?{self::BI2*} bi2a : bi2b).{self::BI2::value});
final self::BI3A* bi3a = new self::BI3A::•([@vm.inferred-type.metadata=int] self::smiOrMint);
diff --git a/pkg/vm/testcases/transformations/type_flow/transformer/write_only_field2.dart.expect b/pkg/vm/testcases/transformations/type_flow/transformer/write_only_field2.dart.expect
index c2f2f87..664dad2 100644
--- a/pkg/vm/testcases/transformations/type_flow/transformer/write_only_field2.dart.expect
+++ b/pkg/vm/testcases/transformations/type_flow/transformer/write_only_field2.dart.expect
@@ -61,7 +61,7 @@
[@vm.call-site-attributes.metadata=receiverType:#lib::C<dart.core::num*>*] [@vm.direct-call.metadata=#lib::D.bar] c.{self::C::bar} = 3.14;
});
self::E* e = new self::F::•();
- exp::Expect::equals(42, [@vm.direct-call.metadata=#lib::F.bar] [@vm.inferred-type.metadata=dart.core::_Smi (value: 42)] e.{self::E::bar});
+ let final core::int* #t2 = [@vm.direct-call.metadata=#lib::F.bar] [@vm.inferred-type.metadata=dart.core::_Smi (value: 42)] e.{self::E::bar} in exp::Expect::equals();
exp::Expect::isTrue(![@vm.inferred-type.metadata=dart.core::bool] core::identical(#C2, #C4));
[@vm.direct-call.metadata=#lib::I.foo] [@vm.inferred-type.metadata=!? (skip check)] new self::I::•().{self::I::foo}();
5;
diff --git a/runtime/vm/compiler/backend/flow_graph.cc b/runtime/vm/compiler/backend/flow_graph.cc
index dc5b713..0b7acfc 100644
--- a/runtime/vm/compiler/backend/flow_graph.cc
+++ b/runtime/vm/compiler/backend/flow_graph.cc
@@ -2382,10 +2382,9 @@
int num_args_checked =
MethodRecognizer::NumArgsCheckedForStaticCall(target);
const ICData& ic_data = ICData::ZoneHandle(
- zone, ICData::New(function, String::Handle(zone, target.name()),
- arguments_descriptor, call->deopt_id(),
- num_args_checked, ICData::kStatic));
- ic_data.AddTarget(target);
+ zone, ICData::NewForStaticCall(
+ function, target, arguments_descriptor,
+ call->deopt_id(), num_args_checked, ICData::kStatic));
call->set_ic_data(&ic_data);
}
}
diff --git a/runtime/vm/compiler/backend/flow_graph_compiler.cc b/runtime/vm/compiler/backend/flow_graph_compiler.cc
index 0502402..c06d36d 100644
--- a/runtime/vm/compiler/backend/flow_graph_compiler.cc
+++ b/runtime/vm/compiler/backend/flow_graph_compiler.cc
@@ -1932,12 +1932,10 @@
return res;
}
- const ICData& ic_data = ICData::ZoneHandle(
- zone(),
- ICData::New(parsed_function().function(),
- String::Handle(zone(), target.name()), arguments_descriptor,
- deopt_id, num_args_tested, rebind_rule));
- ic_data.AddTarget(target);
+ const auto& ic_data = ICData::ZoneHandle(
+ zone(), ICData::NewForStaticCall(parsed_function().function(), target,
+ arguments_descriptor, deopt_id,
+ num_args_tested, rebind_rule));
if (deopt_id_to_ic_data_ != NULL) {
(*deopt_id_to_ic_data_)[deopt_id] = &ic_data;
}
diff --git a/runtime/vm/compiler/backend/il_deserializer.cc b/runtime/vm/compiler/backend/il_deserializer.cc
index dcc40c0..6c30d95 100644
--- a/runtime/vm/compiler/backend/il_deserializer.cc
+++ b/runtime/vm/compiler/backend/il_deserializer.cc
@@ -2327,7 +2327,7 @@
}
ASSERT(parsed_function_ != nullptr);
- const auto& ic_data = ICData::ZoneHandle(
+ auto& ic_data = ICData::ZoneHandle(
zone(), ICData::New(parsed_function_->function(), *function_name,
arguments_descriptor, inst->deopt_id(),
num_args_checked, rebind_rule, *type_ptr));
@@ -2360,7 +2360,9 @@
StoreError(entry, "expected a zero count for no checked args");
return false;
}
- ic_data.AddTarget(target);
+ ic_data = ICData::NewForStaticCall(parsed_function_->function(), target,
+ arguments_descriptor, inst->deopt_id(),
+ num_args_checked, rebind_rule);
continue;
}
@@ -2386,7 +2388,7 @@
}
if (auto const call = inst->AsInstanceCall()) {
- call->set_ic_data(&ic_data);
+ call->set_ic_data(const_cast<const ICData*>(&ic_data));
} else if (auto const call = inst->AsStaticCall()) {
call->set_ic_data(&ic_data);
}
diff --git a/runtime/vm/object.cc b/runtime/vm/object.cc
index e1e4f70..9c47fa6 100644
--- a/runtime/vm/object.cc
+++ b/runtime/vm/object.cc
@@ -11331,33 +11331,36 @@
if (src.IsNull()) {
return Symbols::OptimizedOut().raw();
}
- intptr_t relative_line_number = line_number - line_offset();
+ intptr_t target_line = line_number - line_offset();
intptr_t current_line = 1;
- intptr_t line_start_idx = -1;
- intptr_t last_char_idx = -1;
- for (intptr_t ix = 0;
- (ix < src.Length()) && (current_line <= relative_line_number); ix++) {
- if ((current_line == relative_line_number) && (line_start_idx < 0)) {
- line_start_idx = ix;
+ intptr_t start = 0;
+ // First find the right line, if present...
+ for (; start < src.Length(); start++) {
+ if (current_line == target_line) {
+ break;
}
- if (src.CharAt(ix) == '\n') {
+ const uint16_t c = src.CharAt(start);
+ // Only count '\r' as a line terminator if not followed by a '\n'.
+ if (c == '\n' || (c == '\r' && (start + 1 >= src.Length() ||
+ src.CharAt(start + 1) != '\n'))) {
current_line++;
- } else if (src.CharAt(ix) == '\r') {
- if ((ix + 1 != src.Length()) && (src.CharAt(ix + 1) != '\n')) {
- current_line++;
- }
- } else {
- last_char_idx = ix;
}
}
- // Guarantee that returned string is never NULL.
-
- if (line_start_idx >= 0) {
- return String::SubString(src, line_start_idx,
- last_char_idx - line_start_idx + 1, space);
- } else {
- return Symbols::Empty().raw();
+ if (current_line == target_line) {
+ // ... and then find its end, excluding any line terminator.
+ intptr_t end = start;
+ for (; end < src.Length(); end++) {
+ const uint16_t c = src.CharAt(end);
+ if (c == '\n' || c == '\r') {
+ break;
+ }
+ }
+ // Return the contents of the line.
+ return String::SubString(src, start, end - start, space);
}
+
+ // Not found, so return the empty string.
+ return Symbols::Empty().raw();
}
StringPtr Script::GetSnippet(TokenPosition from, TokenPosition to) const {
@@ -15252,44 +15255,6 @@
return is_smi_two_args_op;
}
-// Used for unoptimized static calls when no class-ids are checked.
-void ICData::AddTarget(const Function& target) const {
- ASSERT(!target.IsNull());
- if (NumArgsTested() > 0) {
- // Create a fake cid entry, so that we can store the target.
- if (NumArgsTested() == 1) {
- AddReceiverCheck(kObjectCid, target, 1);
- } else {
- GrowableArray<intptr_t> class_ids(NumArgsTested());
- for (intptr_t i = 0; i < NumArgsTested(); i++) {
- class_ids.Add(kObjectCid);
- }
- AddCheck(class_ids, target);
- }
- return;
- }
- ASSERT(NumArgsTested() == 0);
- // Can add only once.
- const intptr_t old_num = NumberOfChecks();
- ASSERT(old_num == 0);
- Thread* thread = Thread::Current();
- REUSABLE_ARRAY_HANDLESCOPE(thread);
- Array& data = thread->ArrayHandle();
- data = entries();
- const intptr_t new_len = data.Length() + TestEntryLength();
- data = Array::Grow(data, new_len, Heap::kOld);
- WriteSentinel(data, TestEntryLength());
- intptr_t data_pos = old_num * TestEntryLength();
- ASSERT(!target.IsNull());
- data.SetAt(data_pos + TargetIndexFor(NumArgsTested()), target);
- // Set count to 0 as this is called during compilation, before the
- // call has been executed.
- data.SetAt(data_pos + CountIndexFor(NumArgsTested()), Object::smi_zero());
- // Multithreaded access to ICData requires setting of array to be the last
- // operation.
- set_entries(data);
-}
-
bool ICData::ValidateInterceptor(const Function& target) const {
#if !defined(DART_PRECOMPILED_RUNTIME)
const String& name = String::Handle(target_name());
@@ -15319,17 +15284,14 @@
ASSERT(class_ids.length() == num_args_tested);
const intptr_t old_num = NumberOfChecks();
Array& data = Array::Handle(entries());
+
// ICData of static calls with NumArgsTested() > 0 have initially a
- // dummy set of cids entered (see ICData::AddTarget). That entry is
+ // dummy set of cids entered (see ICData::NewForStaticCall). That entry is
// overwritten by first real type feedback data.
- if (old_num == 1) {
- bool has_dummy_entry = true;
- for (intptr_t i = 0; i < num_args_tested; i++) {
- if (Smi::Value(Smi::RawCast(data.At(i))) != kObjectCid) {
- has_dummy_entry = false;
- break;
- }
- }
+ if (old_num == 1 && num_args_tested == 2) {
+ const bool has_dummy_entry =
+ Smi::Value(Smi::RawCast(data.At(0))) == kObjectCid &&
+ Smi::Value(Smi::RawCast(data.At(1))) == kObjectCid;
if (has_dummy_entry) {
ASSERT(target.raw() == data.At(TargetIndexFor(num_args_tested)));
// Replace dummy entry.
@@ -15885,6 +15847,43 @@
return result.raw();
}
+ICDataPtr ICData::NewForStaticCall(const Function& owner,
+ const Function& target,
+ const Array& arguments_descriptor,
+ intptr_t deopt_id,
+ intptr_t num_args_tested,
+ RebindRule rebind_rule) {
+ ASSERT(!target.IsNull());
+
+ Zone* zone = Thread::Current()->zone();
+ const auto& target_name = String::Handle(zone, target.name());
+ const auto& result = ICData::Handle(
+ zone, NewDescriptor(zone, owner, target_name, arguments_descriptor,
+ deopt_id, num_args_tested, rebind_rule,
+ Object::null_abstract_type()));
+
+ const intptr_t kNumEntries = 2; // 1 entry and a sentinel.
+ const intptr_t entry_len =
+ TestEntryLengthFor(num_args_tested, /*tracking_exactness=*/false);
+ const auto& array =
+ Array::Handle(zone, Array::New(kNumEntries * entry_len, Heap::kOld));
+
+ // See `MethodRecognizer::NumArgsCheckedForStaticCall`.
+ ASSERT(num_args_tested == 0 || num_args_tested == 2);
+ if (num_args_tested == 2) {
+ const auto& object_cid = Smi::Handle(zone, Smi::New(kObjectCid));
+ array.SetAt(0, object_cid);
+ array.SetAt(1, object_cid);
+ }
+ array.SetAt(CountIndexFor(num_args_tested), Object::smi_zero());
+ array.SetAt(TargetIndexFor(num_args_tested), target);
+ WriteSentinel(array, entry_len);
+
+ result.set_entries(array);
+
+ return result.raw();
+}
+
#if !defined(DART_PRECOMPILED_RUNTIME)
ICDataPtr ICData::NewFrom(const ICData& from, intptr_t num_args_tested) {
// See comment in [ICData::Clone] why we access the megamorphic bit first.
diff --git a/runtime/vm/object.h b/runtime/vm/object.h
index 0ec0812..d9429bb 100644
--- a/runtime/vm/object.h
+++ b/runtime/vm/object.h
@@ -2089,9 +2089,6 @@
// Returns true if this is a two arg smi operation.
bool AddSmiSmiCheckForFastSmiStubs() const;
- // Used for unoptimized static calls when no class-ids are checked.
- void AddTarget(const Function& target) const;
-
// Adding checks.
// Adds one more class test to ICData. Length of 'classes' must be equal to
@@ -2162,6 +2159,13 @@
intptr_t num_args_tested,
RebindRule rebind_rule,
const AbstractType& receiver_type = Object::null_abstract_type());
+ static ICDataPtr NewForStaticCall(const Function& owner,
+ const Function& target,
+ const Array& arguments_descriptor,
+ intptr_t deopt_id,
+ intptr_t num_args_tested,
+ RebindRule rebind_rule);
+
static ICDataPtr NewFrom(const ICData& from, intptr_t num_args_tested);
// Generates a new ICData with descriptor and data array copied (deep clone).
diff --git a/runtime/vm/object_test.cc b/runtime/vm/object_test.cc
index 336008f..47f28ff 100644
--- a/runtime/vm/object_test.cc
+++ b/runtime/vm/object_test.cc
@@ -2354,24 +2354,104 @@
}
}
-ISOLATE_UNIT_TEST_CASE(Script) {
- const char* url_chars = "builtin:test-case";
- const char* source_chars = "This will not compile.";
- const String& url = String::Handle(String::New(url_chars));
- const String& source = String::Handle(String::New(source_chars));
- const Script& script = Script::Handle(Script::New(url, source));
+static void CheckLinesWithOffset(Zone* zone, const intptr_t offset) {
+ const char* url_chars = "";
+ // Eight lines, mix of \n, \r, \r\n line terminators, lines 3, 4, 7, and 8
+ // are non-empty. Ends with a \r as a double-check that the \r followed by
+ // \n check doesn't go out of bounds.
+ const char* source_chars = "\n\nxyz\nabc\r\n\n\r\ndef\rghi\r";
+ const String& url = String::Handle(zone, String::New(url_chars));
+ const String& source = String::Handle(zone, String::New(source_chars));
+ const Script& script = Script::Handle(zone, Script::New(url, source));
EXPECT(!script.IsNull());
EXPECT(script.IsScript());
- String& str = String::Handle(script.url());
- EXPECT_EQ(17, str.Length());
- EXPECT_EQ('b', str.CharAt(0));
- EXPECT_EQ(':', str.CharAt(7));
- EXPECT_EQ('e', str.CharAt(16));
- str = script.Source();
- EXPECT_EQ(22, str.Length());
- EXPECT_EQ('T', str.CharAt(0));
- EXPECT_EQ('n', str.CharAt(10));
- EXPECT_EQ('.', str.CharAt(21));
+ script.SetLocationOffset(offset, 10);
+ auto& str = String::Handle(zone);
+ str = script.GetLine(offset + 1);
+ EXPECT_STREQ("", str.ToCString());
+ str = script.GetLine(offset + 2);
+ EXPECT_STREQ("", str.ToCString());
+ str = script.GetLine(offset + 3);
+ EXPECT_STREQ("xyz", str.ToCString());
+ str = script.GetLine(offset + 4);
+ EXPECT_STREQ("abc", str.ToCString());
+ str = script.GetLine(offset + 5);
+ EXPECT_STREQ("", str.ToCString());
+ str = script.GetLine(offset + 6);
+ EXPECT_STREQ("", str.ToCString());
+ str = script.GetLine(offset + 7);
+ EXPECT_STREQ("def", str.ToCString());
+ str = script.GetLine(offset + 8);
+ EXPECT_STREQ("ghi", str.ToCString());
+ // Lines not in the range of (1-based) line indices in the source should
+ // return the empty string.
+ str = script.GetLine(-500);
+ EXPECT_STREQ("", str.ToCString());
+ str = script.GetLine(0);
+ EXPECT_STREQ("", str.ToCString());
+ if (offset > 0) {
+ str = script.GetLine(1); // Absolute, not relative to offset.
+ EXPECT_STREQ("", str.ToCString());
+ }
+ if (offset > 2) {
+ str = script.GetLine(3); // Absolute, not relative to offset.
+ EXPECT_STREQ("", str.ToCString());
+ }
+ str = script.GetLine(offset);
+ EXPECT_STREQ("", str.ToCString());
+ str = script.GetLine(offset + 9);
+ EXPECT_STREQ("", str.ToCString());
+ str = script.GetLine(offset + 10000);
+ EXPECT_STREQ("", str.ToCString());
+}
+
+ISOLATE_UNIT_TEST_CASE(Script) {
+ {
+ const char* url_chars = "builtin:test-case";
+ const char* source_chars = "This will not compile.";
+ const String& url = String::Handle(String::New(url_chars));
+ const String& source = String::Handle(String::New(source_chars));
+ const Script& script = Script::Handle(Script::New(url, source));
+ EXPECT(!script.IsNull());
+ EXPECT(script.IsScript());
+ String& str = String::Handle(script.url());
+ EXPECT_EQ(17, str.Length());
+ EXPECT_EQ('b', str.CharAt(0));
+ EXPECT_EQ(':', str.CharAt(7));
+ EXPECT_EQ('e', str.CharAt(16));
+ str = script.Source();
+ EXPECT_EQ(22, str.Length());
+ EXPECT_EQ('T', str.CharAt(0));
+ EXPECT_EQ('n', str.CharAt(10));
+ EXPECT_EQ('.', str.CharAt(21));
+ }
+
+ CheckLinesWithOffset(Z, 0);
+ CheckLinesWithOffset(Z, 500);
+ CheckLinesWithOffset(Z, 10000);
+
+ {
+ const char* url_chars = "";
+ // Single line, no terminators.
+ const char* source_chars = "abc";
+ const String& url = String::Handle(String::New(url_chars));
+ const String& source = String::Handle(String::New(source_chars));
+ const Script& script = Script::Handle(Script::New(url, source));
+ EXPECT(!script.IsNull());
+ EXPECT(script.IsScript());
+ auto& str = String::Handle(Z);
+ str = script.GetLine(1);
+ EXPECT_STREQ("abc", str.ToCString());
+ // Lines not in the source should return the empty string.
+ str = script.GetLine(-500);
+ EXPECT_STREQ("", str.ToCString());
+ str = script.GetLine(0);
+ EXPECT_STREQ("", str.ToCString());
+ str = script.GetLine(2);
+ EXPECT_STREQ("", str.ToCString());
+ str = script.GetLine(10000);
+ EXPECT_STREQ("", str.ToCString());
+ }
TransitionVMToNative transition(thread);
const char* kScript = "main() {}";
@@ -3066,10 +3146,9 @@
// Check ICData for unoptimized static calls.
const intptr_t kNumArgsChecked = 0;
- const ICData& scall_icdata =
- ICData::Handle(ICData::New(function, target_name, args_descriptor, 57,
- kNumArgsChecked, ICData::kInstance));
- scall_icdata.AddTarget(target1);
+ const ICData& scall_icdata = ICData::Handle(
+ ICData::NewForStaticCall(function, target1, args_descriptor, 57,
+ kNumArgsChecked, ICData::kInstance));
EXPECT_EQ(target1.raw(), scall_icdata.GetTargetAt(0));
}
diff --git a/tools/VERSION b/tools/VERSION
index 21097be..5c1cbeb 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
MAJOR 2
MINOR 12
PATCH 0
-PRERELEASE 80
+PRERELEASE 81
PRERELEASE_PATCH 0
\ No newline at end of file
