From c4ea2d95cdcfa6772f208fa8be764a6bdcbd4030 Mon Sep 17 00:00:00 2001 From: Jens Johansen Date: Fri, 14 Oct 2022 09:48:38 +0000 Subject: [PATCH] [parser] Add comments to calls Change-Id: Ide38846a6ff93c0bb7714ad89cc2f14accb0ed20 Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/263126 Commit-Queue: Jens Johansen Reviewed-by: Brian Wilkerson --- .../lib/src/parser/parser_impl.dart | 19 +- .../lib/src/parser/parser_main.dart | 2 +- .../lib/src/parser/quote.dart | 2 +- .../lib/src/parser/stack_listener.dart | 2 +- .../lib/src/parser/type_info.dart | 2 +- .../lib/src/parser/type_info_impl.dart | 6 +- .../lib/src/scanner/string_canonicalizer.dart | 6 +- .../lib/src/scanner/token.dart | 431 +++++++++--------- .../comments_on_certain_arguments_tool.dart | 56 ++- 9 files changed, 295 insertions(+), 231 deletions(-) diff --git a/pkg/_fe_analyzer_shared/lib/src/parser/parser_impl.dart b/pkg/_fe_analyzer_shared/lib/src/parser/parser_impl.dart index 70deef75aaa..89a646062c0 100644 --- a/pkg/_fe_analyzer_shared/lib/src/parser/parser_impl.dart +++ b/pkg/_fe_analyzer_shared/lib/src/parser/parser_impl.dart @@ -1266,7 +1266,7 @@ class Parser { // Insert missing 'Function' below. reportRecoverableError(endGroup, missingParameterMessage(MemberKind.FunctionTypeAlias)); - rewriter.insertParens(endGroup, /*includeIdentifier =*/ false); + rewriter.insertParens(endGroup, /* includeIdentifier = */ false); recover = true; } else if (optional('(', endGroup.next!) && endGroup.next!.endGroup != null && @@ -2856,7 +2856,7 @@ class Parser { } else { token = IdentifierContext.extensionShowHideElementMemberOrType .ensureIdentifier(token.next!, this); - listener.handleShowHideIdentifier(null, token); + listener.handleShowHideIdentifier(/* modifier = */ null, token); } } ++elementCount; @@ -4447,7 +4447,7 @@ class Parser { codes.templateExperimentNotEnabled .withArguments("triple-shift", "2.14")); operator = rewriter.replaceNextTokensWithSyntheticToken( - name, 2, TokenType.GT_GT_GT); + name, /* count = */ 2, TokenType.GT_GT_GT); } } } @@ -5520,7 +5520,7 @@ class Parser { .withArguments("triple-shift", "2.14")); assert(next == operator); next = rewriter.replaceNextTokensWithSyntheticToken( - token, 2, TokenType.GT_GT_GT_EQ); + token, /* count = */ 2, TokenType.GT_GT_GT_EQ); operator = next; } token = optional('throw', next.next!) @@ -5615,7 +5615,7 @@ class Parser { .withArguments("triple-shift", "2.14")); assert(next == operator); next = rewriter.replaceNextTokensWithSyntheticToken( - token, 2, TokenType.GT_GT_GT); + token, /* count = */ 2, TokenType.GT_GT_GT); operator = next; } } @@ -5646,7 +5646,7 @@ class Parser { if (!enteredLoop && _recoverAtPrecedenceLevel && !_currentlyRecovering) { // Attempt recovery if (_attemptPrecedenceLevelRecovery( - token, precedence, /*currentLevel = */ -1, allowCascades, typeArg)) { + token, precedence, /* currentLevel = */ -1, allowCascades, typeArg)) { return _parsePrecedenceExpressionLoop( precedence, allowCascades, typeArg, token); } @@ -6121,7 +6121,8 @@ class Parser { } bool old = mayParseFunctionExpressions; mayParseFunctionExpressions = true; - token = parseParenthesizedExpressionOrRecordLiteral(token, null); + token = parseParenthesizedExpressionOrRecordLiteral( + token, /* constKeywordForRecord = */ null); mayParseFunctionExpressions = old; return token; } @@ -6243,7 +6244,7 @@ class Parser { listener.handleParenthesizedCondition(begin, case_); } else { token = ensureCloseParen(token, begin); - listener.handleParenthesizedCondition(begin, null); + listener.handleParenthesizedCondition(begin, /* case_ = */ null); } assert(optional(')', token)); return token; @@ -9293,7 +9294,7 @@ class Parser { // grammar token = parsePrecedenceExpression( token, SELECTOR_PRECEDENCE, /* allowCascades = */ false); - listener.handleConstantPattern(null); + listener.handleConstantPattern(/* constKeyword = */ null); return token; } diff --git a/pkg/_fe_analyzer_shared/lib/src/parser/parser_main.dart b/pkg/_fe_analyzer_shared/lib/src/parser/parser_main.dart index a560e0131a7..6117b4f7384 100644 --- a/pkg/_fe_analyzer_shared/lib/src/parser/parser_main.dart +++ b/pkg/_fe_analyzer_shared/lib/src/parser/parser_main.dart @@ -33,7 +33,7 @@ class DebugListener extends Listener { mainEntryPoint(List arguments) async { for (String argument in arguments) { if (argument.startsWith("@")) { - Uri uri = Uri.base.resolve(argument.substring(/* startIndex = */ 1)); + Uri uri = Uri.base.resolve(argument.substring(/* start = */ 1)); await for (String file in new File.fromUri(uri) .openRead() .cast>() diff --git a/pkg/_fe_analyzer_shared/lib/src/parser/quote.dart b/pkg/_fe_analyzer_shared/lib/src/parser/quote.dart index fe146ce046a..d180f412e65 100644 --- a/pkg/_fe_analyzer_shared/lib/src/parser/quote.dart +++ b/pkg/_fe_analyzer_shared/lib/src/parser/quote.dart @@ -130,7 +130,7 @@ String unescapeLastStringPart(String last, Quote quote, Object location, bool isLastQuoteSynthetic, UnescapeErrorListener listener) { int end = last.length - (isLastQuoteSynthetic ? 0 : lastQuoteLength(quote)); return unescape( - last.substring(/* startIndex = */ 0, end), quote, location, listener); + last.substring(/* start = */ 0, end), quote, location, listener); } String unescapeString( diff --git a/pkg/_fe_analyzer_shared/lib/src/parser/stack_listener.dart b/pkg/_fe_analyzer_shared/lib/src/parser/stack_listener.dart index 65dbb99ffae..4f32679fd02 100644 --- a/pkg/_fe_analyzer_shared/lib/src/parser/stack_listener.dart +++ b/pkg/_fe_analyzer_shared/lib/src/parser/stack_listener.dart @@ -261,7 +261,7 @@ abstract class StackListener extends Listener { String s = " $o"; int index = s.indexOf("\n"); if (index != -1) { - s = s.substring(/* startIndex = */ 0, index) + "..."; + s = s.substring(/* start = */ 0, index) + "..."; } print(s); } diff --git a/pkg/_fe_analyzer_shared/lib/src/parser/type_info.dart b/pkg/_fe_analyzer_shared/lib/src/parser/type_info.dart index 7dee64b23a0..8d284db7552 100644 --- a/pkg/_fe_analyzer_shared/lib/src/parser/type_info.dart +++ b/pkg/_fe_analyzer_shared/lib/src/parser/type_info.dart @@ -403,7 +403,7 @@ TypeParamOrArgInfo computeTypeParamOrArg(Token token, } else if (optional('(', next)) { bool recordType = false; if (isPossibleRecordType(next)) { - TypeInfo type = computeType(beginGroup, false); + TypeInfo type = computeType(beginGroup, /* required = */ false); if (type is ComplexTypeInfo && (type.recordType || type.gftReturnTypeHasRecordType) && !type.recovered) { diff --git a/pkg/_fe_analyzer_shared/lib/src/parser/type_info_impl.dart b/pkg/_fe_analyzer_shared/lib/src/parser/type_info_impl.dart index 09903485788..396939e66f7 100644 --- a/pkg/_fe_analyzer_shared/lib/src/parser/type_info_impl.dart +++ b/pkg/_fe_analyzer_shared/lib/src/parser/type_info_impl.dart @@ -600,9 +600,11 @@ class ComplexTypeInfo implements TypeInfo { // generate the full type. noType.parseType(token, parser); } else if (recordType) { - token = parser.parseRecordType(start, token, beforeQuestionMark != null); + token = parser.parseRecordType(start, token, + /* questionMarkPartOfType = */ beforeQuestionMark != null); } else if (gftReturnTypeHasRecordType) { - token = parser.parseRecordType(start, token, true); + token = parser.parseRecordType( + start, token, /* questionMarkPartOfType = */ true); } else { Token typeRefOrPrefix = token.next!; if (optional('void', typeRefOrPrefix)) { diff --git a/pkg/_fe_analyzer_shared/lib/src/scanner/string_canonicalizer.dart b/pkg/_fe_analyzer_shared/lib/src/scanner/string_canonicalizer.dart index 68506c002a4..d17d0da4fb0 100644 --- a/pkg/_fe_analyzer_shared/lib/src/scanner/string_canonicalizer.dart +++ b/pkg/_fe_analyzer_shared/lib/src/scanner/string_canonicalizer.dart @@ -18,7 +18,8 @@ abstract class Node { class StringNode extends Node { StringNode(super.payload, super.next); - int get hash => StringCanonicalizer.hashString(payload, 0, payload.length); + int get hash => + StringCanonicalizer.hashString(payload, /* start = */ 0, payload.length); } class Utf8Node extends Node { @@ -163,7 +164,8 @@ class StringCanonicalizer { String canonicalizeString(String data) { if (_count > _size) rehash(); - final int index = hashString(data, 0, data.length) & (_size - 1); + final int index = + hashString(data, /* start = */ 0, data.length) & (_size - 1); Node? s = _nodes[index]; Node? t = s; while (t != null) { diff --git a/pkg/_fe_analyzer_shared/lib/src/scanner/token.dart b/pkg/_fe_analyzer_shared/lib/src/scanner/token.dart index d9d21af7a4d..ccbb40f1f02 100644 --- a/pkg/_fe_analyzer_shared/lib/src/scanner/token.dart +++ b/pkg/_fe_analyzer_shared/lib/src/scanner/token.dart @@ -106,231 +106,235 @@ enum KeywordStyle { */ class Keyword extends TokenType { static const Keyword ABSTRACT = const Keyword( - 79, "abstract", "ABSTRACT", KeywordStyle.builtIn, + /* index = */ 79, "abstract", "ABSTRACT", KeywordStyle.builtIn, isModifier: true); - static const Keyword AS = const Keyword(80, "as", "AS", KeywordStyle.builtIn, + static const Keyword AS = const Keyword( + /* index = */ 80, "as", "AS", KeywordStyle.builtIn, precedence: RELATIONAL_PRECEDENCE); - static const Keyword ASSERT = - const Keyword(81, "assert", "ASSERT", KeywordStyle.reserved); + static const Keyword ASSERT = const Keyword( + /* index = */ 81, "assert", "ASSERT", KeywordStyle.reserved); static const Keyword ASYNC = - const Keyword(82, "async", "ASYNC", KeywordStyle.pseudo); + const Keyword(/* index = */ 82, "async", "ASYNC", KeywordStyle.pseudo); static const Keyword AUGMENT = const Keyword( - 83, "augment", "AUGMENT", KeywordStyle.builtIn, + /* index = */ 83, "augment", "AUGMENT", KeywordStyle.builtIn, isModifier: true); static const Keyword AWAIT = - const Keyword(84, "await", "AWAIT", KeywordStyle.pseudo); + const Keyword(/* index = */ 84, "await", "AWAIT", KeywordStyle.pseudo); static const Keyword BREAK = - const Keyword(85, "break", "BREAK", KeywordStyle.reserved); + const Keyword(/* index = */ 85, "break", "BREAK", KeywordStyle.reserved); static const Keyword CASE = - const Keyword(86, "case", "CASE", KeywordStyle.reserved); + const Keyword(/* index = */ 86, "case", "CASE", KeywordStyle.reserved); static const Keyword CATCH = - const Keyword(87, "catch", "CATCH", KeywordStyle.reserved); + const Keyword(/* index = */ 87, "catch", "CATCH", KeywordStyle.reserved); static const Keyword CLASS = const Keyword( - 88, "class", "CLASS", KeywordStyle.reserved, + /* index = */ 88, "class", "CLASS", KeywordStyle.reserved, isTopLevelKeyword: true); static const Keyword CONST = const Keyword( - 89, "const", "CONST", KeywordStyle.reserved, + /* index = */ 89, "const", "CONST", KeywordStyle.reserved, isModifier: true); - static const Keyword CONTINUE = - const Keyword(90, "continue", "CONTINUE", KeywordStyle.reserved); + static const Keyword CONTINUE = const Keyword( + /* index = */ 90, "continue", "CONTINUE", KeywordStyle.reserved); static const Keyword COVARIANT = const Keyword( - 91, "covariant", "COVARIANT", KeywordStyle.builtIn, + /* index = */ 91, "covariant", "COVARIANT", KeywordStyle.builtIn, isModifier: true); - static const Keyword DEFAULT = - const Keyword(92, "default", "DEFAULT", KeywordStyle.reserved); + static const Keyword DEFAULT = const Keyword( + /* index = */ 92, "default", "DEFAULT", KeywordStyle.reserved); - static const Keyword DEFERRED = - const Keyword(93, "deferred", "DEFERRED", KeywordStyle.builtIn); + static const Keyword DEFERRED = const Keyword( + /* index = */ 93, "deferred", "DEFERRED", KeywordStyle.builtIn); static const Keyword DO = - const Keyword(94, "do", "DO", KeywordStyle.reserved); + const Keyword(/* index = */ 94, "do", "DO", KeywordStyle.reserved); - static const Keyword DYNAMIC = - const Keyword(95, "dynamic", "DYNAMIC", KeywordStyle.builtIn); + static const Keyword DYNAMIC = const Keyword( + /* index = */ 95, "dynamic", "DYNAMIC", KeywordStyle.builtIn); static const Keyword ELSE = - const Keyword(96, "else", "ELSE", KeywordStyle.reserved); + const Keyword(/* index = */ 96, "else", "ELSE", KeywordStyle.reserved); static const Keyword ENUM = const Keyword( - 97, "enum", "ENUM", KeywordStyle.reserved, + /* index = */ 97, "enum", "ENUM", KeywordStyle.reserved, isTopLevelKeyword: true); static const Keyword EXPORT = const Keyword( - 98, "export", "EXPORT", KeywordStyle.builtIn, + /* index = */ 98, "export", "EXPORT", KeywordStyle.builtIn, isTopLevelKeyword: true); - static const Keyword EXTENDS = - const Keyword(99, "extends", "EXTENDS", KeywordStyle.reserved); + static const Keyword EXTENDS = const Keyword( + /* index = */ 99, "extends", "EXTENDS", KeywordStyle.reserved); static const Keyword EXTENSION = const Keyword( - 100, "extension", "EXTENSION", KeywordStyle.builtIn, + /* index = */ 100, "extension", "EXTENSION", KeywordStyle.builtIn, isTopLevelKeyword: true); static const Keyword EXTERNAL = const Keyword( - 101, "external", "EXTERNAL", KeywordStyle.builtIn, + /* index = */ 101, "external", "EXTERNAL", KeywordStyle.builtIn, isModifier: true); - static const Keyword FACTORY = - const Keyword(102, "factory", "FACTORY", KeywordStyle.builtIn); + static const Keyword FACTORY = const Keyword( + /* index = */ 102, "factory", "FACTORY", KeywordStyle.builtIn); static const Keyword FALSE = - const Keyword(103, "false", "FALSE", KeywordStyle.reserved); + const Keyword(/* index = */ 103, "false", "FALSE", KeywordStyle.reserved); static const Keyword FINAL = const Keyword( - 104, "final", "FINAL", KeywordStyle.reserved, + /* index = */ 104, "final", "FINAL", KeywordStyle.reserved, isModifier: true); - static const Keyword FINALLY = - const Keyword(105, "finally", "FINALLY", KeywordStyle.reserved); + static const Keyword FINALLY = const Keyword( + /* index = */ 105, "finally", "FINALLY", KeywordStyle.reserved); static const Keyword FOR = - const Keyword(106, "for", "FOR", KeywordStyle.reserved); + const Keyword(/* index = */ 106, "for", "FOR", KeywordStyle.reserved); - static const Keyword FUNCTION = - const Keyword(107, "Function", "FUNCTION", KeywordStyle.builtIn); + static const Keyword FUNCTION = const Keyword( + /* index = */ 107, "Function", "FUNCTION", KeywordStyle.builtIn); static const Keyword GET = - const Keyword(108, "get", "GET", KeywordStyle.builtIn); + const Keyword(/* index = */ 108, "get", "GET", KeywordStyle.builtIn); static const Keyword HIDE = - const Keyword(109, "hide", "HIDE", KeywordStyle.pseudo); + const Keyword(/* index = */ 109, "hide", "HIDE", KeywordStyle.pseudo); static const Keyword IF = - const Keyword(110, "if", "IF", KeywordStyle.reserved); + const Keyword(/* index = */ 110, "if", "IF", KeywordStyle.reserved); - static const Keyword IMPLEMENTS = - const Keyword(111, "implements", "IMPLEMENTS", KeywordStyle.builtIn); + static const Keyword IMPLEMENTS = const Keyword( + /* index = */ 111, "implements", "IMPLEMENTS", KeywordStyle.builtIn); static const Keyword IMPORT = const Keyword( - 112, "import", "IMPORT", KeywordStyle.builtIn, + /* index = */ 112, "import", "IMPORT", KeywordStyle.builtIn, isTopLevelKeyword: true); static const Keyword IN = - const Keyword(113, "in", "IN", KeywordStyle.reserved); + const Keyword(/* index = */ 113, "in", "IN", KeywordStyle.reserved); static const Keyword INOUT = - const Keyword(114, "inout", "INOUT", KeywordStyle.pseudo); + const Keyword(/* index = */ 114, "inout", "INOUT", KeywordStyle.pseudo); - static const Keyword INTERFACE = - const Keyword(115, "interface", "INTERFACE", KeywordStyle.builtIn); + static const Keyword INTERFACE = const Keyword( + /* index = */ 115, "interface", "INTERFACE", KeywordStyle.builtIn); static const Keyword IS = const Keyword( - 116, "is", "IS", KeywordStyle.reserved, + /* index = */ 116, "is", "IS", KeywordStyle.reserved, precedence: RELATIONAL_PRECEDENCE); static const Keyword LATE = const Keyword( - 117, "late", "LATE", KeywordStyle.builtIn, + /* index = */ 117, "late", "LATE", KeywordStyle.builtIn, isModifier: true); static const Keyword LIBRARY = const Keyword( - 118, "library", "LIBRARY", KeywordStyle.builtIn, + /* index = */ 118, "library", "LIBRARY", KeywordStyle.builtIn, isTopLevelKeyword: true); static const Keyword MIXIN = const Keyword( - 119, "mixin", "MIXIN", KeywordStyle.builtIn, + /* index = */ 119, "mixin", "MIXIN", KeywordStyle.builtIn, isTopLevelKeyword: true); static const Keyword NATIVE = - const Keyword(120, "native", "NATIVE", KeywordStyle.pseudo); + const Keyword(/* index = */ 120, "native", "NATIVE", KeywordStyle.pseudo); static const Keyword NEW = - const Keyword(121, "new", "NEW", KeywordStyle.reserved); + const Keyword(/* index = */ 121, "new", "NEW", KeywordStyle.reserved); static const Keyword NULL = - const Keyword(122, "null", "NULL", KeywordStyle.reserved); + const Keyword(/* index = */ 122, "null", "NULL", KeywordStyle.reserved); - static const Keyword OF = const Keyword(123, "of", "OF", KeywordStyle.pseudo); + static const Keyword OF = + const Keyword(/* index = */ 123, "of", "OF", KeywordStyle.pseudo); - static const Keyword ON = const Keyword(124, "on", "ON", KeywordStyle.pseudo); + static const Keyword ON = + const Keyword(/* index = */ 124, "on", "ON", KeywordStyle.pseudo); - static const Keyword OPERATOR = - const Keyword(125, "operator", "OPERATOR", KeywordStyle.builtIn); + static const Keyword OPERATOR = const Keyword( + /* index = */ 125, "operator", "OPERATOR", KeywordStyle.builtIn); static const Keyword OUT = - const Keyword(126, "out", "OUT", KeywordStyle.pseudo); + const Keyword(/* index = */ 126, "out", "OUT", KeywordStyle.pseudo); static const Keyword PART = const Keyword( - 127, "part", "PART", KeywordStyle.builtIn, + /* index = */ 127, "part", "PART", KeywordStyle.builtIn, isTopLevelKeyword: true); static const Keyword PATCH = - const Keyword(128, "patch", "PATCH", KeywordStyle.pseudo); + const Keyword(/* index = */ 128, "patch", "PATCH", KeywordStyle.pseudo); static const Keyword REQUIRED = const Keyword( - 129, "required", "REQUIRED", KeywordStyle.builtIn, + /* index = */ 129, "required", "REQUIRED", KeywordStyle.builtIn, isModifier: true); - static const Keyword RETHROW = - const Keyword(130, "rethrow", "RETHROW", KeywordStyle.reserved); + static const Keyword RETHROW = const Keyword( + /* index = */ 130, "rethrow", "RETHROW", KeywordStyle.reserved); - static const Keyword RETURN = - const Keyword(131, "return", "RETURN", KeywordStyle.reserved); + static const Keyword RETURN = const Keyword( + /* index = */ 131, "return", "RETURN", KeywordStyle.reserved); static const Keyword SET = - const Keyword(132, "set", "SET", KeywordStyle.builtIn); + const Keyword(/* index = */ 132, "set", "SET", KeywordStyle.builtIn); static const Keyword SHOW = - const Keyword(133, "show", "SHOW", KeywordStyle.pseudo); + const Keyword(/* index = */ 133, "show", "SHOW", KeywordStyle.pseudo); static const Keyword SOURCE = - const Keyword(134, "source", "SOURCE", KeywordStyle.pseudo); + const Keyword(/* index = */ 134, "source", "SOURCE", KeywordStyle.pseudo); static const Keyword STATIC = const Keyword( - 135, "static", "STATIC", KeywordStyle.builtIn, + /* index = */ 135, "static", "STATIC", KeywordStyle.builtIn, isModifier: true); static const Keyword SUPER = - const Keyword(136, "super", "SUPER", KeywordStyle.reserved); + const Keyword(/* index = */ 136, "super", "SUPER", KeywordStyle.reserved); - static const Keyword SWITCH = - const Keyword(137, "switch", "SWITCH", KeywordStyle.reserved); + static const Keyword SWITCH = const Keyword( + /* index = */ 137, "switch", "SWITCH", KeywordStyle.reserved); static const Keyword SYNC = - const Keyword(138, "sync", "SYNC", KeywordStyle.pseudo); + const Keyword(/* index = */ 138, "sync", "SYNC", KeywordStyle.pseudo); static const Keyword THIS = - const Keyword(139, "this", "THIS", KeywordStyle.reserved); + const Keyword(/* index = */ 139, "this", "THIS", KeywordStyle.reserved); static const Keyword THROW = - const Keyword(140, "throw", "THROW", KeywordStyle.reserved); + const Keyword(/* index = */ 140, "throw", "THROW", KeywordStyle.reserved); static const Keyword TRUE = - const Keyword(141, "true", "TRUE", KeywordStyle.reserved); + const Keyword(/* index = */ 141, "true", "TRUE", KeywordStyle.reserved); static const Keyword TRY = - const Keyword(142, "try", "TRY", KeywordStyle.reserved); + const Keyword(/* index = */ 142, "try", "TRY", KeywordStyle.reserved); static const Keyword TYPEDEF = const Keyword( - 143, "typedef", "TYPEDEF", KeywordStyle.builtIn, + /* index = */ 143, "typedef", "TYPEDEF", KeywordStyle.builtIn, isTopLevelKeyword: true); - static const Keyword VAR = - const Keyword(144, "var", "VAR", KeywordStyle.reserved, isModifier: true); + static const Keyword VAR = const Keyword( + /* index = */ 144, "var", "VAR", KeywordStyle.reserved, + isModifier: true); static const Keyword VOID = - const Keyword(145, "void", "VOID", KeywordStyle.reserved); + const Keyword(/* index = */ 145, "void", "VOID", KeywordStyle.reserved); static const Keyword WHILE = - const Keyword(146, "while", "WHILE", KeywordStyle.reserved); + const Keyword(/* index = */ 146, "while", "WHILE", KeywordStyle.reserved); static const Keyword WITH = - const Keyword(147, "with", "WITH", KeywordStyle.reserved); + const Keyword(/* index = */ 147, "with", "WITH", KeywordStyle.reserved); static const Keyword YIELD = - const Keyword(148, "yield", "YIELD", KeywordStyle.pseudo); + const Keyword(/* index = */ 148, "yield", "YIELD", KeywordStyle.pseudo); static const List values = const [ ABSTRACT, @@ -1202,50 +1206,55 @@ class TokenType { * The type of the token that marks the start or end of the input. */ static const TokenType EOF = - const TokenType(0, '', 'EOF', NO_PRECEDENCE, EOF_TOKEN); + const TokenType(/* index = */ 0, '', 'EOF', NO_PRECEDENCE, EOF_TOKEN); static const TokenType DOUBLE = const TokenType( - 1, 'double', 'DOUBLE', NO_PRECEDENCE, DOUBLE_TOKEN, + /* index = */ 1, 'double', 'DOUBLE', NO_PRECEDENCE, DOUBLE_TOKEN, stringValue: null); - static const TokenType HEXADECIMAL = const TokenType( - 2, 'hexadecimal', 'HEXADECIMAL', NO_PRECEDENCE, HEXADECIMAL_TOKEN, + static const TokenType HEXADECIMAL = const TokenType(/* index = */ 2, + 'hexadecimal', 'HEXADECIMAL', NO_PRECEDENCE, HEXADECIMAL_TOKEN, stringValue: null); - static const TokenType IDENTIFIER = const TokenType( - 3, 'identifier', 'IDENTIFIER', NO_PRECEDENCE, IDENTIFIER_TOKEN, + static const TokenType IDENTIFIER = const TokenType(/* index = */ 3, + 'identifier', 'IDENTIFIER', NO_PRECEDENCE, IDENTIFIER_TOKEN, stringValue: null); static const TokenType INT = const TokenType( - 4, 'int', 'INT', NO_PRECEDENCE, INT_TOKEN, + /* index = */ 4, 'int', 'INT', NO_PRECEDENCE, INT_TOKEN, stringValue: null); - static const TokenType MULTI_LINE_COMMENT = const TokenType( - 5, 'comment', 'MULTI_LINE_COMMENT', NO_PRECEDENCE, COMMENT_TOKEN, + static const TokenType MULTI_LINE_COMMENT = const TokenType(/* index = */ 5, + 'comment', 'MULTI_LINE_COMMENT', NO_PRECEDENCE, COMMENT_TOKEN, stringValue: null); - static const TokenType SCRIPT_TAG = - const TokenType(6, 'script', 'SCRIPT_TAG', NO_PRECEDENCE, SCRIPT_TOKEN); + static const TokenType SCRIPT_TAG = const TokenType( + /* index = */ 6, 'script', 'SCRIPT_TAG', NO_PRECEDENCE, SCRIPT_TOKEN); - static const TokenType SINGLE_LINE_COMMENT = const TokenType( - 7, 'comment', 'SINGLE_LINE_COMMENT', NO_PRECEDENCE, COMMENT_TOKEN, + static const TokenType SINGLE_LINE_COMMENT = const TokenType(/* index = */ 7, + 'comment', 'SINGLE_LINE_COMMENT', NO_PRECEDENCE, COMMENT_TOKEN, stringValue: null); static const TokenType STRING = const TokenType( - 8, 'string', 'STRING', NO_PRECEDENCE, STRING_TOKEN, + /* index = */ 8, 'string', 'STRING', NO_PRECEDENCE, STRING_TOKEN, stringValue: null); - static const TokenType AMPERSAND = const TokenType( - 9, '&', 'AMPERSAND', BITWISE_AND_PRECEDENCE, AMPERSAND_TOKEN, + static const TokenType AMPERSAND = const TokenType(/* index = */ 9, '&', + 'AMPERSAND', BITWISE_AND_PRECEDENCE, AMPERSAND_TOKEN, isOperator: true, isBinaryOperator: true, isUserDefinableOperator: true); - static const TokenType AMPERSAND_AMPERSAND = const TokenType(10, '&&', - 'AMPERSAND_AMPERSAND', LOGICAL_AND_PRECEDENCE, AMPERSAND_AMPERSAND_TOKEN, - isOperator: true, isBinaryOperator: true); + static const TokenType AMPERSAND_AMPERSAND = const TokenType( + /* index = */ 10, + '&&', + 'AMPERSAND_AMPERSAND', + LOGICAL_AND_PRECEDENCE, + AMPERSAND_AMPERSAND_TOKEN, + isOperator: true, + isBinaryOperator: true); // This is not yet part of the language and not supported by fasta static const TokenType AMPERSAND_AMPERSAND_EQ = const TokenType( - 11, + /* index = */ 11, '&&=', 'AMPERSAND_AMPERSAND_EQ', ASSIGNMENT_PRECEDENCE, @@ -1253,262 +1262,278 @@ class TokenType { binaryOperatorOfCompoundAssignment: TokenType.AMPERSAND_AMPERSAND, isOperator: true); - static const TokenType AMPERSAND_EQ = const TokenType( - 12, '&=', 'AMPERSAND_EQ', ASSIGNMENT_PRECEDENCE, AMPERSAND_EQ_TOKEN, + static const TokenType AMPERSAND_EQ = const TokenType(/* index = */ 12, '&=', + 'AMPERSAND_EQ', ASSIGNMENT_PRECEDENCE, AMPERSAND_EQ_TOKEN, binaryOperatorOfCompoundAssignment: TokenType.AMPERSAND, isOperator: true); static const TokenType AT = - const TokenType(13, '@', 'AT', NO_PRECEDENCE, AT_TOKEN); + const TokenType(/* index = */ 13, '@', 'AT', NO_PRECEDENCE, AT_TOKEN); static const TokenType BANG = const TokenType( - 14, '!', 'BANG', PREFIX_PRECEDENCE, BANG_TOKEN, + /* index = */ 14, '!', 'BANG', PREFIX_PRECEDENCE, BANG_TOKEN, isOperator: true); static const TokenType BANG_EQ = const TokenType( - 15, '!=', 'BANG_EQ', EQUALITY_PRECEDENCE, BANG_EQ_TOKEN, + /* index = */ 15, '!=', 'BANG_EQ', EQUALITY_PRECEDENCE, BANG_EQ_TOKEN, isOperator: true); - static const TokenType BANG_EQ_EQ = const TokenType( - 16, '!==', 'BANG_EQ_EQ', EQUALITY_PRECEDENCE, BANG_EQ_EQ_TOKEN); + static const TokenType BANG_EQ_EQ = const TokenType(/* index = */ 16, '!==', + 'BANG_EQ_EQ', EQUALITY_PRECEDENCE, BANG_EQ_EQ_TOKEN); static const TokenType BAR = const TokenType( - 17, '|', 'BAR', BITWISE_OR_PRECEDENCE, BAR_TOKEN, + /* index = */ 17, '|', 'BAR', BITWISE_OR_PRECEDENCE, BAR_TOKEN, isOperator: true, isBinaryOperator: true, isUserDefinableOperator: true); static const TokenType BAR_BAR = const TokenType( - 18, '||', 'BAR_BAR', LOGICAL_OR_PRECEDENCE, BAR_BAR_TOKEN, + /* index = */ 18, '||', 'BAR_BAR', LOGICAL_OR_PRECEDENCE, BAR_BAR_TOKEN, isOperator: true, isBinaryOperator: true); // This is not yet part of the language and not supported by fasta - static const TokenType BAR_BAR_EQ = const TokenType( - 19, '||=', 'BAR_BAR_EQ', ASSIGNMENT_PRECEDENCE, BAR_BAR_EQ_TOKEN, + static const TokenType BAR_BAR_EQ = const TokenType(/* index = */ 19, '||=', + 'BAR_BAR_EQ', ASSIGNMENT_PRECEDENCE, BAR_BAR_EQ_TOKEN, binaryOperatorOfCompoundAssignment: TokenType.BAR_BAR, isOperator: true); static const TokenType BAR_EQ = const TokenType( - 20, '|=', 'BAR_EQ', ASSIGNMENT_PRECEDENCE, BAR_EQ_TOKEN, + /* index = */ 20, '|=', 'BAR_EQ', ASSIGNMENT_PRECEDENCE, BAR_EQ_TOKEN, binaryOperatorOfCompoundAssignment: TokenType.BAR, isOperator: true); - static const TokenType COLON = - const TokenType(21, ':', 'COLON', NO_PRECEDENCE, COLON_TOKEN); + static const TokenType COLON = const TokenType( + /* index = */ 21, ':', 'COLON', NO_PRECEDENCE, COLON_TOKEN); - static const TokenType COMMA = - const TokenType(22, ',', 'COMMA', NO_PRECEDENCE, COMMA_TOKEN); + static const TokenType COMMA = const TokenType( + /* index = */ 22, ',', 'COMMA', NO_PRECEDENCE, COMMA_TOKEN); static const TokenType CARET = const TokenType( - 23, '^', 'CARET', BITWISE_XOR_PRECEDENCE, CARET_TOKEN, + /* index = */ 23, '^', 'CARET', BITWISE_XOR_PRECEDENCE, CARET_TOKEN, isOperator: true, isBinaryOperator: true, isUserDefinableOperator: true); static const TokenType CARET_EQ = const TokenType( - 24, '^=', 'CARET_EQ', ASSIGNMENT_PRECEDENCE, CARET_EQ_TOKEN, + /* index = */ 24, '^=', 'CARET_EQ', ASSIGNMENT_PRECEDENCE, CARET_EQ_TOKEN, binaryOperatorOfCompoundAssignment: TokenType.CARET, isOperator: true); - static const TokenType CLOSE_CURLY_BRACKET = const TokenType( - 25, '}', 'CLOSE_CURLY_BRACKET', NO_PRECEDENCE, CLOSE_CURLY_BRACKET_TOKEN); + static const TokenType CLOSE_CURLY_BRACKET = const TokenType(/* index = */ 25, + '}', 'CLOSE_CURLY_BRACKET', NO_PRECEDENCE, CLOSE_CURLY_BRACKET_TOKEN); - static const TokenType CLOSE_PAREN = - const TokenType(26, ')', 'CLOSE_PAREN', NO_PRECEDENCE, CLOSE_PAREN_TOKEN); + static const TokenType CLOSE_PAREN = const TokenType( + /* index = */ 26, ')', 'CLOSE_PAREN', NO_PRECEDENCE, CLOSE_PAREN_TOKEN); - static const TokenType CLOSE_SQUARE_BRACKET = const TokenType(27, ']', - 'CLOSE_SQUARE_BRACKET', NO_PRECEDENCE, CLOSE_SQUARE_BRACKET_TOKEN); + static const TokenType CLOSE_SQUARE_BRACKET = const TokenType( + /* index = */ 27, + ']', + 'CLOSE_SQUARE_BRACKET', + NO_PRECEDENCE, + CLOSE_SQUARE_BRACKET_TOKEN); static const TokenType EQ = const TokenType( - 28, '=', 'EQ', ASSIGNMENT_PRECEDENCE, EQ_TOKEN, + /* index = */ 28, '=', 'EQ', ASSIGNMENT_PRECEDENCE, EQ_TOKEN, isOperator: true); static const TokenType EQ_EQ = const TokenType( - 29, '==', 'EQ_EQ', EQUALITY_PRECEDENCE, EQ_EQ_TOKEN, + /* index = */ 29, '==', 'EQ_EQ', EQUALITY_PRECEDENCE, EQ_EQ_TOKEN, isOperator: true, isBinaryOperator: true, isUserDefinableOperator: true); /// The `===` operator is not supported in the Dart language /// but is parsed as such by the scanner to support better recovery /// when a JavaScript code snippet is pasted into a Dart file. static const TokenType EQ_EQ_EQ = const TokenType( - 30, '===', 'EQ_EQ_EQ', EQUALITY_PRECEDENCE, EQ_EQ_EQ_TOKEN); + /* index = */ 30, '===', 'EQ_EQ_EQ', EQUALITY_PRECEDENCE, EQ_EQ_EQ_TOKEN); - static const TokenType FUNCTION = - const TokenType(31, '=>', 'FUNCTION', NO_PRECEDENCE, FUNCTION_TOKEN); + static const TokenType FUNCTION = const TokenType( + /* index = */ 31, '=>', 'FUNCTION', NO_PRECEDENCE, FUNCTION_TOKEN); static const TokenType GT = const TokenType( - 32, '>', 'GT', RELATIONAL_PRECEDENCE, GT_TOKEN, + /* index = */ 32, '>', 'GT', RELATIONAL_PRECEDENCE, GT_TOKEN, isOperator: true, isBinaryOperator: true, isUserDefinableOperator: true); static const TokenType GT_EQ = const TokenType( - 33, '>=', 'GT_EQ', RELATIONAL_PRECEDENCE, GT_EQ_TOKEN, + /* index = */ 33, '>=', 'GT_EQ', RELATIONAL_PRECEDENCE, GT_EQ_TOKEN, isOperator: true, isBinaryOperator: true, isUserDefinableOperator: true); static const TokenType GT_GT = const TokenType( - 34, '>>', 'GT_GT', SHIFT_PRECEDENCE, GT_GT_TOKEN, + /* index = */ 34, '>>', 'GT_GT', SHIFT_PRECEDENCE, GT_GT_TOKEN, isOperator: true, isBinaryOperator: true, isUserDefinableOperator: true); - static const TokenType GT_GT_EQ = const TokenType( - 35, '>>=', 'GT_GT_EQ', ASSIGNMENT_PRECEDENCE, GT_GT_EQ_TOKEN, + static const TokenType GT_GT_EQ = const TokenType(/* index = */ 35, '>>=', + 'GT_GT_EQ', ASSIGNMENT_PRECEDENCE, GT_GT_EQ_TOKEN, binaryOperatorOfCompoundAssignment: TokenType.GT_GT, isOperator: true); static const TokenType GT_GT_GT = const TokenType( - 36, '>>>', 'GT_GT_GT', SHIFT_PRECEDENCE, GT_GT_GT_TOKEN, + /* index = */ 36, '>>>', 'GT_GT_GT', SHIFT_PRECEDENCE, GT_GT_GT_TOKEN, isOperator: true, isBinaryOperator: true, isUserDefinableOperator: true); - static const TokenType GT_GT_GT_EQ = const TokenType( - 37, '>>>=', 'GT_GT_GT_EQ', ASSIGNMENT_PRECEDENCE, GT_GT_GT_EQ_TOKEN, + static const TokenType GT_GT_GT_EQ = const TokenType(/* index = */ 37, '>>>=', + 'GT_GT_GT_EQ', ASSIGNMENT_PRECEDENCE, GT_GT_GT_EQ_TOKEN, binaryOperatorOfCompoundAssignment: TokenType.GT_GT_GT, isOperator: true); static const TokenType HASH = - const TokenType(38, '#', 'HASH', NO_PRECEDENCE, HASH_TOKEN); + const TokenType(/* index = */ 38, '#', 'HASH', NO_PRECEDENCE, HASH_TOKEN); static const TokenType INDEX = const TokenType( - 39, '[]', 'INDEX', SELECTOR_PRECEDENCE, INDEX_TOKEN, + /* index = */ 39, '[]', 'INDEX', SELECTOR_PRECEDENCE, INDEX_TOKEN, isOperator: true, isUserDefinableOperator: true); static const TokenType INDEX_EQ = const TokenType( - 40, '[]=', 'INDEX_EQ', NO_PRECEDENCE, INDEX_EQ_TOKEN, + /* index = */ 40, '[]=', 'INDEX_EQ', NO_PRECEDENCE, INDEX_EQ_TOKEN, isOperator: true, isUserDefinableOperator: true); static const TokenType LT = const TokenType( - 41, '<', 'LT', RELATIONAL_PRECEDENCE, LT_TOKEN, + /* index = */ 41, '<', 'LT', RELATIONAL_PRECEDENCE, LT_TOKEN, isOperator: true, isBinaryOperator: true, isUserDefinableOperator: true); static const TokenType LT_EQ = const TokenType( - 42, '<=', 'LT_EQ', RELATIONAL_PRECEDENCE, LT_EQ_TOKEN, + /* index = */ 42, '<=', 'LT_EQ', RELATIONAL_PRECEDENCE, LT_EQ_TOKEN, isOperator: true, isBinaryOperator: true, isUserDefinableOperator: true); static const TokenType LT_LT = const TokenType( - 43, '<<', 'LT_LT', SHIFT_PRECEDENCE, LT_LT_TOKEN, + /* index = */ 43, '<<', 'LT_LT', SHIFT_PRECEDENCE, LT_LT_TOKEN, isOperator: true, isBinaryOperator: true, isUserDefinableOperator: true); - static const TokenType LT_LT_EQ = const TokenType( - 44, '<<=', 'LT_LT_EQ', ASSIGNMENT_PRECEDENCE, LT_LT_EQ_TOKEN, + static const TokenType LT_LT_EQ = const TokenType(/* index = */ 44, '<<=', + 'LT_LT_EQ', ASSIGNMENT_PRECEDENCE, LT_LT_EQ_TOKEN, binaryOperatorOfCompoundAssignment: TokenType.LT_LT, isOperator: true); static const TokenType MINUS = const TokenType( - 45, '-', 'MINUS', ADDITIVE_PRECEDENCE, MINUS_TOKEN, + /* index = */ 45, '-', 'MINUS', ADDITIVE_PRECEDENCE, MINUS_TOKEN, isOperator: true, isBinaryOperator: true, isUserDefinableOperator: true); static const TokenType MINUS_EQ = const TokenType( - 46, '-=', 'MINUS_EQ', ASSIGNMENT_PRECEDENCE, MINUS_EQ_TOKEN, + /* index = */ 46, '-=', 'MINUS_EQ', ASSIGNMENT_PRECEDENCE, MINUS_EQ_TOKEN, binaryOperatorOfCompoundAssignment: TokenType.MINUS, isOperator: true); - static const TokenType MINUS_MINUS = const TokenType( - 47, '--', 'MINUS_MINUS', POSTFIX_PRECEDENCE, MINUS_MINUS_TOKEN, + static const TokenType MINUS_MINUS = const TokenType(/* index = */ 47, '--', + 'MINUS_MINUS', POSTFIX_PRECEDENCE, MINUS_MINUS_TOKEN, isOperator: true); - static const TokenType OPEN_CURLY_BRACKET = const TokenType( - 48, '{', 'OPEN_CURLY_BRACKET', NO_PRECEDENCE, OPEN_CURLY_BRACKET_TOKEN); + static const TokenType OPEN_CURLY_BRACKET = const TokenType(/* index = */ 48, + '{', 'OPEN_CURLY_BRACKET', NO_PRECEDENCE, OPEN_CURLY_BRACKET_TOKEN); - static const TokenType OPEN_PAREN = const TokenType( - 49, '(', 'OPEN_PAREN', SELECTOR_PRECEDENCE, OPEN_PAREN_TOKEN); + static const TokenType OPEN_PAREN = const TokenType(/* index = */ 49, '(', + 'OPEN_PAREN', SELECTOR_PRECEDENCE, OPEN_PAREN_TOKEN); - static const TokenType OPEN_SQUARE_BRACKET = const TokenType(50, '[', - 'OPEN_SQUARE_BRACKET', SELECTOR_PRECEDENCE, OPEN_SQUARE_BRACKET_TOKEN); + static const TokenType OPEN_SQUARE_BRACKET = const TokenType( + /* index = */ 50, + '[', + 'OPEN_SQUARE_BRACKET', + SELECTOR_PRECEDENCE, + OPEN_SQUARE_BRACKET_TOKEN); - static const TokenType PERCENT = const TokenType( - 51, '%', 'PERCENT', MULTIPLICATIVE_PRECEDENCE, PERCENT_TOKEN, + static const TokenType PERCENT = const TokenType(/* index = */ 51, '%', + 'PERCENT', MULTIPLICATIVE_PRECEDENCE, PERCENT_TOKEN, isOperator: true, isBinaryOperator: true, isUserDefinableOperator: true); - static const TokenType PERCENT_EQ = const TokenType( - 52, '%=', 'PERCENT_EQ', ASSIGNMENT_PRECEDENCE, PERCENT_EQ_TOKEN, + static const TokenType PERCENT_EQ = const TokenType(/* index = */ 52, '%=', + 'PERCENT_EQ', ASSIGNMENT_PRECEDENCE, PERCENT_EQ_TOKEN, binaryOperatorOfCompoundAssignment: TokenType.PERCENT, isOperator: true); - static const TokenType PERIOD = - const TokenType(53, '.', 'PERIOD', SELECTOR_PRECEDENCE, PERIOD_TOKEN); + static const TokenType PERIOD = const TokenType( + /* index = */ 53, '.', 'PERIOD', SELECTOR_PRECEDENCE, PERIOD_TOKEN); - static const TokenType PERIOD_PERIOD = const TokenType( - 54, '..', 'PERIOD_PERIOD', CASCADE_PRECEDENCE, PERIOD_PERIOD_TOKEN, + static const TokenType PERIOD_PERIOD = const TokenType(/* index = */ 54, '..', + 'PERIOD_PERIOD', CASCADE_PRECEDENCE, PERIOD_PERIOD_TOKEN, isOperator: true); static const TokenType PLUS = const TokenType( - 55, '+', 'PLUS', ADDITIVE_PRECEDENCE, PLUS_TOKEN, + /* index = */ 55, '+', 'PLUS', ADDITIVE_PRECEDENCE, PLUS_TOKEN, isOperator: true, isBinaryOperator: true, isUserDefinableOperator: true); static const TokenType PLUS_EQ = const TokenType( - 56, '+=', 'PLUS_EQ', ASSIGNMENT_PRECEDENCE, PLUS_EQ_TOKEN, + /* index = */ 56, '+=', 'PLUS_EQ', ASSIGNMENT_PRECEDENCE, PLUS_EQ_TOKEN, binaryOperatorOfCompoundAssignment: TokenType.PLUS, isOperator: true); static const TokenType PLUS_PLUS = const TokenType( - 57, '++', 'PLUS_PLUS', POSTFIX_PRECEDENCE, PLUS_PLUS_TOKEN, + /* index = */ 57, '++', 'PLUS_PLUS', POSTFIX_PRECEDENCE, PLUS_PLUS_TOKEN, isOperator: true); static const TokenType QUESTION = const TokenType( - 58, '?', 'QUESTION', CONDITIONAL_PRECEDENCE, QUESTION_TOKEN, + /* index = */ 58, '?', 'QUESTION', CONDITIONAL_PRECEDENCE, QUESTION_TOKEN, isOperator: true); - static const TokenType QUESTION_PERIOD = const TokenType( - 59, '?.', 'QUESTION_PERIOD', SELECTOR_PRECEDENCE, QUESTION_PERIOD_TOKEN, + static const TokenType QUESTION_PERIOD = const TokenType(/* index = */ 59, + '?.', 'QUESTION_PERIOD', SELECTOR_PRECEDENCE, QUESTION_PERIOD_TOKEN, isOperator: true); - static const TokenType QUESTION_QUESTION = const TokenType(60, '??', - 'QUESTION_QUESTION', IF_NULL_PRECEDENCE, QUESTION_QUESTION_TOKEN, + static const TokenType QUESTION_QUESTION = const TokenType(/* index = */ 60, + '??', 'QUESTION_QUESTION', IF_NULL_PRECEDENCE, QUESTION_QUESTION_TOKEN, isOperator: true, isBinaryOperator: true); - static const TokenType QUESTION_QUESTION_EQ = const TokenType(61, '??=', - 'QUESTION_QUESTION_EQ', ASSIGNMENT_PRECEDENCE, QUESTION_QUESTION_EQ_TOKEN, + static const TokenType QUESTION_QUESTION_EQ = const TokenType( + /* index = */ 61, + '??=', + 'QUESTION_QUESTION_EQ', + ASSIGNMENT_PRECEDENCE, + QUESTION_QUESTION_EQ_TOKEN, binaryOperatorOfCompoundAssignment: TokenType.QUESTION_QUESTION, isOperator: true); - static const TokenType SEMICOLON = - const TokenType(62, ';', 'SEMICOLON', NO_PRECEDENCE, SEMICOLON_TOKEN); + static const TokenType SEMICOLON = const TokenType( + /* index = */ 62, ';', 'SEMICOLON', NO_PRECEDENCE, SEMICOLON_TOKEN); static const TokenType SLASH = const TokenType( - 63, '/', 'SLASH', MULTIPLICATIVE_PRECEDENCE, SLASH_TOKEN, + /* index = */ 63, '/', 'SLASH', MULTIPLICATIVE_PRECEDENCE, SLASH_TOKEN, isOperator: true, isBinaryOperator: true, isUserDefinableOperator: true); static const TokenType SLASH_EQ = const TokenType( - 64, '/=', 'SLASH_EQ', ASSIGNMENT_PRECEDENCE, SLASH_EQ_TOKEN, + /* index = */ 64, '/=', 'SLASH_EQ', ASSIGNMENT_PRECEDENCE, SLASH_EQ_TOKEN, binaryOperatorOfCompoundAssignment: TokenType.SLASH, isOperator: true); static const TokenType STAR = const TokenType( - 65, '*', 'STAR', MULTIPLICATIVE_PRECEDENCE, STAR_TOKEN, + /* index = */ 65, '*', 'STAR', MULTIPLICATIVE_PRECEDENCE, STAR_TOKEN, isOperator: true, isBinaryOperator: true, isUserDefinableOperator: true); static const TokenType STAR_EQ = const TokenType( - 66, '*=', 'STAR_EQ', ASSIGNMENT_PRECEDENCE, STAR_EQ_TOKEN, + /* index = */ 66, '*=', 'STAR_EQ', ASSIGNMENT_PRECEDENCE, STAR_EQ_TOKEN, binaryOperatorOfCompoundAssignment: TokenType.STAR, isOperator: true); static const TokenType STRING_INTERPOLATION_EXPRESSION = const TokenType( - 67, + /* index = */ 67, '\${', 'STRING_INTERPOLATION_EXPRESSION', NO_PRECEDENCE, STRING_INTERPOLATION_TOKEN); static const TokenType STRING_INTERPOLATION_IDENTIFIER = const TokenType( - 68, + /* index = */ 68, '\$', 'STRING_INTERPOLATION_IDENTIFIER', NO_PRECEDENCE, STRING_INTERPOLATION_IDENTIFIER_TOKEN); static const TokenType TILDE = const TokenType( - 69, '~', 'TILDE', PREFIX_PRECEDENCE, TILDE_TOKEN, + /* index = */ 69, '~', 'TILDE', PREFIX_PRECEDENCE, TILDE_TOKEN, isOperator: true, isUserDefinableOperator: true); - static const TokenType TILDE_SLASH = const TokenType( - 70, '~/', 'TILDE_SLASH', MULTIPLICATIVE_PRECEDENCE, TILDE_SLASH_TOKEN, + static const TokenType TILDE_SLASH = const TokenType(/* index = */ 70, '~/', + 'TILDE_SLASH', MULTIPLICATIVE_PRECEDENCE, TILDE_SLASH_TOKEN, isOperator: true, isBinaryOperator: true, isUserDefinableOperator: true); - static const TokenType TILDE_SLASH_EQ = const TokenType( - 71, '~/=', 'TILDE_SLASH_EQ', ASSIGNMENT_PRECEDENCE, TILDE_SLASH_EQ_TOKEN, + static const TokenType TILDE_SLASH_EQ = const TokenType(/* index = */ 71, + '~/=', 'TILDE_SLASH_EQ', ASSIGNMENT_PRECEDENCE, TILDE_SLASH_EQ_TOKEN, binaryOperatorOfCompoundAssignment: TokenType.TILDE_SLASH, isOperator: true); - static const TokenType BACKPING = - const TokenType(72, '`', 'BACKPING', NO_PRECEDENCE, BACKPING_TOKEN); + static const TokenType BACKPING = const TokenType( + /* index = */ 72, '`', 'BACKPING', NO_PRECEDENCE, BACKPING_TOKEN); - static const TokenType BACKSLASH = - const TokenType(73, '\\', 'BACKSLASH', NO_PRECEDENCE, BACKSLASH_TOKEN); + static const TokenType BACKSLASH = const TokenType( + /* index = */ 73, '\\', 'BACKSLASH', NO_PRECEDENCE, BACKSLASH_TOKEN); - static const TokenType PERIOD_PERIOD_PERIOD = const TokenType(74, '...', - 'PERIOD_PERIOD_PERIOD', NO_PRECEDENCE, PERIOD_PERIOD_PERIOD_TOKEN); + static const TokenType PERIOD_PERIOD_PERIOD = const TokenType( + /* index = */ 74, + '...', + 'PERIOD_PERIOD_PERIOD', + NO_PRECEDENCE, + PERIOD_PERIOD_PERIOD_TOKEN); static const TokenType PERIOD_PERIOD_PERIOD_QUESTION = const TokenType( - 75, + /* index = */ 75, '...?', 'PERIOD_PERIOD_PERIOD_QUESTION', NO_PRECEDENCE, PERIOD_PERIOD_PERIOD_QUESTION_TOKEN); static const TokenType QUESTION_PERIOD_PERIOD = const TokenType( - 76, + /* index = */ 76, '?..', 'QUESTION_PERIOD_PERIOD', CASCADE_PRECEDENCE, @@ -1521,8 +1546,8 @@ class TokenType { /** * Token type used by error tokens. */ - static const TokenType BAD_INPUT = const TokenType( - 77, 'malformed input', 'BAD_INPUT', NO_PRECEDENCE, BAD_INPUT_TOKEN, + static const TokenType BAD_INPUT = const TokenType(/* index = */ 77, + 'malformed input', 'BAD_INPUT', NO_PRECEDENCE, BAD_INPUT_TOKEN, stringValue: null); /** @@ -1530,7 +1555,7 @@ class TokenType { * recovery (non-analyzer use case). */ static const TokenType RECOVERY = const TokenType( - 78, 'recovery', 'RECOVERY', NO_PRECEDENCE, RECOVERY_TOKEN, + /* index = */ 78, 'recovery', 'RECOVERY', NO_PRECEDENCE, RECOVERY_TOKEN, stringValue: null); // TODO(danrubel): "all" is misleading diff --git a/pkg/front_end/test/comments_on_certain_arguments_tool.dart b/pkg/front_end/test/comments_on_certain_arguments_tool.dart index 675567fbe14..47136c7e91e 100644 --- a/pkg/front_end/test/comments_on_certain_arguments_tool.dart +++ b/pkg/front_end/test/comments_on_certain_arguments_tool.dart @@ -212,6 +212,12 @@ class InvocationVisitor extends RecursiveVisitor { note(node.targetReference.node!, node.arguments, node); } + @override + void visitInstanceInvocation(InstanceInvocation node) { + super.visitInstanceInvocation(node); + note(node.interfaceTargetReference.node!, node.arguments, node); + } + void note( NamedNode node, Arguments arguments, InvocationExpression invocation) { List positionalParameters; @@ -246,35 +252,62 @@ class InvocationVisitor extends RecursiveVisitor { argument.receiver is BoolLiteral) { wantComment = true; } + } else if (argument is Not) { + if (argument.operand is EqualsNull) { + wantComment = true; + } + } else if (argument is EqualsNull) { + wantComment = true; } if (wantComment) { - check(arguments.positional[i], i, positionalParameters[i], node, + check(arguments.positional[i], positionalParameters[i], node, "/* ${positionalParameters[i].name} = */"); } } } } +class LocationFinder extends RecursiveVisitor { + int lowestOffsetFound = -1; + + @override + void defaultNode(Node node) { + // Stop here. We only want to recurse expressions. + } + + @override + void defaultExpression(Expression node) { + if (lowestOffsetFound == -1 || + (node.fileOffset >= 0 && node.fileOffset < lowestOffsetFound)) { + lowestOffsetFound = node.fileOffset; + } + node.visitChildren(this); + } +} + Map cache = {}; -void check( - Expression argumentExpression, - int parameterNumber, - VariableDeclaration parameter, - NamedNode targetNode, - String expectedComment) { +void check(Expression argumentExpression, VariableDeclaration parameter, + NamedNode targetNode, String expectedComment) { if (targetNode is Procedure && targetNode.kind == ProcedureKind.Operator) { // Operator calls doesn't look like 'regular' method calls. return; } - if (argumentExpression.fileOffset == -1) return; + int fileOffset = argumentExpression.fileOffset; + if (fileOffset == -1) return; + + LocationFinder locationFinder = new LocationFinder(); + argumentExpression.accept(locationFinder); + if (locationFinder.lowestOffsetFound != fileOffset) { + fileOffset = locationFinder.lowestOffsetFound; + } Location location = argumentExpression.location!; Token token = cache[location.file]!; - while (token.offset != argumentExpression.fileOffset) { + while (token.offset != fileOffset) { token = token.next!; if (token.isEof) { throw "Couldn't find token for $argumentExpression " - "(${argumentExpression.fileOffset})."; + "(${fileOffset})."; } } bool foundComment = false; @@ -287,7 +320,8 @@ void check( break; } if (commentToken.lexeme.startsWith("/*") && - commentToken.lexeme.endsWith("= */")) { + (commentToken.lexeme.endsWith("= */") || + commentToken.lexeme.endsWith("=*/"))) { badComments.add(commentToken); } commentToken = commentToken.next as CommentToken?;