| // Copyright (c) 2019, 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 'package:analyzer/dart/ast/ast.dart'; |
| import 'package:analyzer/dart/ast/standard_ast_factory.dart'; |
| import 'package:analyzer/dart/ast/token.dart'; |
| import 'package:analyzer/dart/element/element.dart'; |
| import 'package:analyzer/dart/element/type.dart'; |
| import 'package:analyzer/src/dart/ast/ast.dart'; |
| import 'package:analyzer/src/dart/ast/token.dart'; |
| import 'package:analyzer/src/dart/element/element.dart'; |
| import 'package:analyzer/src/dart/element/type.dart'; |
| import 'package:analyzer/src/generated/utilities_dart.dart'; |
| import 'package:analyzer/src/summary/idl.dart'; |
| import 'package:analyzer/src/summary2/reference.dart'; |
| |
| /// Deserializer of fully resolved ASTs from flat buffers. |
| class AstBinaryReader { |
| final Reference _nameRoot; |
| final LinkedNodeReference _linkedReferences; |
| final List<Reference> _references; |
| |
| final UnlinkedTokens _tokensBinary; |
| final List<Token> _tokens; |
| |
| AstBinaryReader(this._nameRoot, this._linkedReferences, this._tokensBinary) |
| : _references = List<Reference>(_linkedReferences.name.length), |
| _tokens = List<Token>(_tokensBinary.type.length); |
| |
| AstNode readNode(LinkedNode data) { |
| if (data == null) return null; |
| |
| switch (data.kind) { |
| case LinkedNodeKind.adjacentStrings: |
| return _read_adjacentStrings(data); |
| case LinkedNodeKind.annotation: |
| return _read_annotation(data); |
| case LinkedNodeKind.argumentList: |
| return _read_argumentList(data); |
| case LinkedNodeKind.asExpression: |
| return _read_asExpression(data); |
| case LinkedNodeKind.assertInitializer: |
| return _read_assertInitializer(data); |
| case LinkedNodeKind.assertStatement: |
| return _read_assertStatement(data); |
| case LinkedNodeKind.assignmentExpression: |
| return _read_assignmentExpression(data); |
| case LinkedNodeKind.awaitExpression: |
| return _read_awaitExpression(data); |
| case LinkedNodeKind.binaryExpression: |
| return _read_binaryExpression(data); |
| case LinkedNodeKind.block: |
| return _read_block(data); |
| case LinkedNodeKind.blockFunctionBody: |
| return _read_blockFunctionBody(data); |
| case LinkedNodeKind.booleanLiteral: |
| return _read_booleanLiteral(data); |
| case LinkedNodeKind.breakStatement: |
| return _read_breakStatement(data); |
| case LinkedNodeKind.cascadeExpression: |
| return _read_cascadeExpression(data); |
| case LinkedNodeKind.catchClause: |
| return _read_catchClause(data); |
| case LinkedNodeKind.classDeclaration: |
| return _read_classDeclaration(data); |
| case LinkedNodeKind.classTypeAlias: |
| return _read_classTypeAlias(data); |
| case LinkedNodeKind.comment: |
| return _read_comment(data); |
| case LinkedNodeKind.compilationUnit: |
| return _read_compilationUnit(data); |
| case LinkedNodeKind.conditionalExpression: |
| return _read_conditionalExpression(data); |
| case LinkedNodeKind.configuration: |
| return _read_configuration(data); |
| case LinkedNodeKind.constructorDeclaration: |
| return _read_constructorDeclaration(data); |
| case LinkedNodeKind.constructorFieldInitializer: |
| return _read_constructorFieldInitializer(data); |
| case LinkedNodeKind.constructorName: |
| return _read_constructorName(data); |
| case LinkedNodeKind.continueStatement: |
| return _read_continueStatement(data); |
| case LinkedNodeKind.declaredIdentifier: |
| return _read_declaredIdentifier(data); |
| case LinkedNodeKind.defaultFormalParameter: |
| return _read_defaultFormalParameter(data); |
| case LinkedNodeKind.doStatement: |
| return _read_doStatement(data); |
| case LinkedNodeKind.dottedName: |
| return _read_dottedName(data); |
| case LinkedNodeKind.doubleLiteral: |
| return _read_doubleLiteral(data); |
| case LinkedNodeKind.emptyFunctionBody: |
| return _read_emptyFunctionBody(data); |
| case LinkedNodeKind.emptyStatement: |
| return _read_emptyStatement(data); |
| case LinkedNodeKind.enumConstantDeclaration: |
| return _read_enumConstantDeclaration(data); |
| case LinkedNodeKind.enumDeclaration: |
| return _read_enumDeclaration(data); |
| case LinkedNodeKind.exportDirective: |
| return _read_exportDirective(data); |
| case LinkedNodeKind.expressionFunctionBody: |
| return _read_expressionFunctionBody(data); |
| case LinkedNodeKind.expressionStatement: |
| return _read_expressionStatement(data); |
| case LinkedNodeKind.extendsClause: |
| return _read_extendsClause(data); |
| case LinkedNodeKind.fieldDeclaration: |
| return _read_fieldDeclaration(data); |
| case LinkedNodeKind.fieldFormalParameter: |
| return _read_fieldFormalParameter(data); |
| case LinkedNodeKind.forEachPartsWithDeclaration: |
| return _read_forEachPartsWithDeclaration(data); |
| case LinkedNodeKind.forEachPartsWithIdentifier: |
| return _read_forEachPartsWithIdentifier(data); |
| case LinkedNodeKind.forElement: |
| return _read_forElement(data); |
| case LinkedNodeKind.forPartsWithExpression: |
| return _read_forPartsWithExpression(data); |
| case LinkedNodeKind.forPartsWithDeclarations: |
| return _read_forPartsWithDeclarations(data); |
| case LinkedNodeKind.forStatement: |
| return _read_forStatement(data); |
| case LinkedNodeKind.formalParameterList: |
| return _read_formalParameterList(data); |
| case LinkedNodeKind.functionDeclaration: |
| return _read_functionDeclaration(data); |
| case LinkedNodeKind.functionDeclarationStatement: |
| return _read_functionDeclarationStatement(data); |
| case LinkedNodeKind.functionExpression: |
| return _read_functionExpression(data); |
| case LinkedNodeKind.functionExpressionInvocation: |
| return _read_functionExpressionInvocation(data); |
| case LinkedNodeKind.functionTypeAlias: |
| return _read_functionTypeAlias(data); |
| case LinkedNodeKind.functionTypedFormalParameter: |
| return _read_functionTypedFormalParameter(data); |
| case LinkedNodeKind.genericFunctionType: |
| return _read_genericFunctionType(data); |
| case LinkedNodeKind.genericTypeAlias: |
| return _read_genericTypeAlias(data); |
| case LinkedNodeKind.hideCombinator: |
| return _read_hideCombinator(data); |
| case LinkedNodeKind.ifElement: |
| return _read_ifElement(data); |
| case LinkedNodeKind.ifStatement: |
| return _read_ifStatement(data); |
| case LinkedNodeKind.implementsClause: |
| return _read_implementsClause(data); |
| case LinkedNodeKind.importDirective: |
| return _read_importDirective(data); |
| case LinkedNodeKind.indexExpression: |
| return _read_indexExpression(data); |
| case LinkedNodeKind.instanceCreationExpression: |
| return _read_instanceCreationExpression(data); |
| case LinkedNodeKind.integerLiteral: |
| return _read_integerLiteral(data); |
| case LinkedNodeKind.interpolationString: |
| return _read_interpolationString(data); |
| case LinkedNodeKind.interpolationExpression: |
| return _read_interpolationExpression(data); |
| case LinkedNodeKind.isExpression: |
| return _read_isExpression(data); |
| case LinkedNodeKind.label: |
| return _read_label(data); |
| case LinkedNodeKind.labeledStatement: |
| return _read_labeledStatement(data); |
| case LinkedNodeKind.libraryDirective: |
| return _read_libraryDirective(data); |
| case LinkedNodeKind.libraryIdentifier: |
| return _read_libraryIdentifier(data); |
| case LinkedNodeKind.listLiteral: |
| return _read_listLiteral(data); |
| case LinkedNodeKind.mapLiteralEntry: |
| return _read_mapLiteralEntry(data); |
| case LinkedNodeKind.methodDeclaration: |
| return _read_methodDeclaration(data); |
| case LinkedNodeKind.methodInvocation: |
| return _read_methodInvocation(data); |
| case LinkedNodeKind.mixinDeclaration: |
| return _read_mixinDeclaration(data); |
| case LinkedNodeKind.namedExpression: |
| return _read_namedExpression(data); |
| case LinkedNodeKind.nullLiteral: |
| return _read_nullLiteral(data); |
| case LinkedNodeKind.onClause: |
| return _read_onClause(data); |
| case LinkedNodeKind.parenthesizedExpression: |
| return _read_parenthesizedExpression(data); |
| case LinkedNodeKind.partDirective: |
| return _read_partDirective(data); |
| case LinkedNodeKind.partOfDirective: |
| return _read_partOfDirective(data); |
| case LinkedNodeKind.postfixExpression: |
| return _read_postfixExpression(data); |
| case LinkedNodeKind.prefixExpression: |
| return _read_prefixExpression(data); |
| case LinkedNodeKind.propertyAccess: |
| return _read_propertyAccess(data); |
| case LinkedNodeKind.prefixedIdentifier: |
| return _read_prefixedIdentifier(data); |
| case LinkedNodeKind.redirectingConstructorInvocation: |
| return _read_redirectingConstructorInvocation(data); |
| case LinkedNodeKind.rethrowExpression: |
| return _read_rethrowExpression(data); |
| case LinkedNodeKind.returnStatement: |
| return _read_returnStatement(data); |
| case LinkedNodeKind.scriptTag: |
| return _read_scriptTag(data); |
| case LinkedNodeKind.setOrMapLiteral: |
| return _read_setOrMapLiteral(data); |
| case LinkedNodeKind.showCombinator: |
| return _read_showCombinator(data); |
| case LinkedNodeKind.simpleFormalParameter: |
| return _read_simpleFormalParameter(data); |
| case LinkedNodeKind.simpleIdentifier: |
| return _read_simpleIdentifier(data); |
| case LinkedNodeKind.simpleStringLiteral: |
| return _read_simpleStringLiteral(data); |
| case LinkedNodeKind.spreadElement: |
| return _read_spreadElement(data); |
| case LinkedNodeKind.stringInterpolation: |
| return _read_stringInterpolation(data); |
| case LinkedNodeKind.superConstructorInvocation: |
| return _read_superConstructorInvocation(data); |
| case LinkedNodeKind.superExpression: |
| return _read_superExpression(data); |
| case LinkedNodeKind.switchCase: |
| return _read_switchCase(data); |
| case LinkedNodeKind.switchDefault: |
| return _read_switchDefault(data); |
| case LinkedNodeKind.switchStatement: |
| return _read_switchStatement(data); |
| case LinkedNodeKind.symbolLiteral: |
| return _read_symbolLiteral(data); |
| case LinkedNodeKind.thisExpression: |
| return _read_thisExpression(data); |
| case LinkedNodeKind.throwExpression: |
| return _read_throwExpression(data); |
| case LinkedNodeKind.topLevelVariableDeclaration: |
| return _read_topLevelVariableDeclaration(data); |
| case LinkedNodeKind.tryStatement: |
| return _read_tryStatement(data); |
| case LinkedNodeKind.typeArgumentList: |
| return _read_typeArgumentList(data); |
| case LinkedNodeKind.typeName: |
| return _read_typeName(data); |
| case LinkedNodeKind.typeParameter: |
| return _read_typeParameter(data); |
| case LinkedNodeKind.typeParameterList: |
| return _read_typeParameterList(data); |
| case LinkedNodeKind.variableDeclaration: |
| return _read_variableDeclaration(data); |
| case LinkedNodeKind.variableDeclarationList: |
| return _read_variableDeclarationList(data); |
| case LinkedNodeKind.variableDeclarationStatement: |
| return _read_variableDeclarationStatement(data); |
| case LinkedNodeKind.whileStatement: |
| return _read_whileStatement(data); |
| case LinkedNodeKind.withClause: |
| return _read_withClause(data); |
| case LinkedNodeKind.yieldStatement: |
| return _read_yieldStatement(data); |
| default: |
| throw UnimplementedError('Expression kind: ${data.kind}'); |
| } |
| } |
| |
| CommentToken _getCommentToken(int index) { |
| var result = _getToken(index); |
| var token = result; |
| while (true) { |
| index = _tokensBinary.next[index]; |
| if (index == 0) return result; |
| |
| var nextToken = _getToken(index); |
| token.next = nextToken; |
| token = nextToken; |
| } |
| } |
| |
| T _getElement<T extends Element>(int index) { |
| return _getReferenceByIndex(index)?.element; |
| } |
| |
| List<T> _getElements<T extends Element>(List<int> indexList) { |
| var result = List<T>(indexList.length); |
| for (var i = 0; i < indexList.length; ++i) { |
| var index = indexList[i]; |
| result[i] = _getElement(index); |
| } |
| return result; |
| } |
| |
| Reference _getReferenceByIndex(int index) { |
| var reference = _references[index]; |
| if (reference != null) return reference; |
| |
| if (index == 0) { |
| _references[index] = _nameRoot; |
| return _nameRoot; |
| } |
| |
| var parentIndex = _linkedReferences.parent[index]; |
| var parent = _getReferenceByIndex(parentIndex); |
| if (parent == null) return null; |
| |
| var name = _linkedReferences.name[index]; |
| reference = parent[name]; |
| _references[index] = reference; |
| |
| return reference; |
| } |
| |
| Token _getToken(int index) { |
| var token = _tokens[index]; |
| if (token == null) { |
| var kind = _tokensBinary.kind[index]; |
| switch (kind) { |
| case UnlinkedTokenKind.nothing: |
| return null; |
| case UnlinkedTokenKind.comment: |
| return CommentToken( |
| _binaryToAstTokenType(_tokensBinary.type[index]), |
| _tokensBinary.lexeme[index], |
| _tokensBinary.offset[index], |
| ); |
| case UnlinkedTokenKind.keyword: |
| return KeywordToken( |
| _binaryToAstTokenType(_tokensBinary.type[index]), |
| _tokensBinary.offset[index], |
| _getCommentToken(_tokensBinary.precedingComment[index]), |
| ); |
| case UnlinkedTokenKind.simple: |
| return SimpleToken( |
| _binaryToAstTokenType(_tokensBinary.type[index]), |
| _tokensBinary.offset[index], |
| _getCommentToken(_tokensBinary.precedingComment[index]), |
| ); |
| case UnlinkedTokenKind.string: |
| return StringToken( |
| _binaryToAstTokenType(_tokensBinary.type[index]), |
| _tokensBinary.lexeme[index], |
| _tokensBinary.offset[index], |
| _getCommentToken(_tokensBinary.precedingComment[index]), |
| ); |
| default: |
| throw UnimplementedError('Token kind: $kind'); |
| } |
| } |
| return token; |
| } |
| |
| List<Token> _getTokens(List<int> indexList) { |
| var result = List<Token>(indexList.length); |
| for (var i = 0; i < indexList.length; ++i) { |
| var index = indexList[i]; |
| result[i] = _getToken(index); |
| } |
| return result; |
| } |
| |
| AdjacentStrings _read_adjacentStrings(LinkedNode data) { |
| return astFactory.adjacentStrings( |
| _readNodeList(data.adjacentStrings_strings), |
| )..staticType = _readType(data.expression_type); |
| } |
| |
| Annotation _read_annotation(LinkedNode data) { |
| return astFactory.annotation( |
| _getToken(data.annotation_atSign), |
| readNode(data.annotation_name), |
| _getToken(data.annotation_period), |
| readNode(data.annotation_constructorName), |
| readNode(data.annotation_arguments), |
| ); |
| } |
| |
| ArgumentList _read_argumentList(LinkedNode data) { |
| return astFactory.argumentList( |
| _getToken(data.argumentList_leftParenthesis), |
| _readNodeList(data.argumentList_arguments), |
| _getToken(data.argumentList_rightParenthesis), |
| ); |
| } |
| |
| AsExpression _read_asExpression(LinkedNode data) { |
| return astFactory.asExpression( |
| readNode(data.asExpression_expression), |
| _getToken(data.asExpression_asOperator), |
| readNode(data.asExpression_type), |
| )..staticType = _readType(data.expression_type); |
| } |
| |
| AssertInitializer _read_assertInitializer(LinkedNode data) { |
| return astFactory.assertInitializer( |
| _getToken(data.assertInitializer_assertKeyword), |
| _getToken(data.assertInitializer_leftParenthesis), |
| readNode(data.assertInitializer_condition), |
| _getToken(data.assertInitializer_comma), |
| readNode(data.assertInitializer_message), |
| _getToken(data.assertInitializer_rightParenthesis), |
| ); |
| } |
| |
| AssertStatement _read_assertStatement(LinkedNode data) { |
| return astFactory.assertStatement( |
| _getToken(data.assertStatement_assertKeyword), |
| _getToken(data.assertStatement_leftParenthesis), |
| readNode(data.assertStatement_condition), |
| _getToken(data.assertStatement_comma), |
| readNode(data.assertStatement_message), |
| _getToken(data.assertStatement_rightParenthesis), |
| _getToken(data.assertStatement_semicolon), |
| ); |
| } |
| |
| AssignmentExpression _read_assignmentExpression(LinkedNode data) { |
| return astFactory.assignmentExpression( |
| readNode(data.assignmentExpression_leftHandSide), |
| _getToken(data.assignmentExpression_operator), |
| readNode(data.assignmentExpression_rightHandSide), |
| ) |
| ..staticElement = _getElement(data.assignmentExpression_element) |
| ..staticType = _readType(data.expression_type); |
| } |
| |
| AwaitExpression _read_awaitExpression(LinkedNode data) { |
| return astFactory.awaitExpression( |
| _getToken(data.awaitExpression_awaitKeyword), |
| readNode(data.awaitExpression_expression), |
| )..staticType = _readType(data.expression_type); |
| } |
| |
| BinaryExpression _read_binaryExpression(LinkedNode data) { |
| return astFactory.binaryExpression( |
| readNode(data.binaryExpression_leftOperand), |
| _getToken(data.binaryExpression_operator), |
| readNode(data.binaryExpression_rightOperand), |
| ) |
| ..staticElement = _getElement(data.binaryExpression_element) |
| ..staticType = _readType(data.expression_type); |
| } |
| |
| Block _read_block(LinkedNode data) { |
| return astFactory.block( |
| _getToken(data.block_leftBracket), |
| _readNodeList(data.block_statements), |
| _getToken(data.block_rightBracket), |
| ); |
| } |
| |
| BlockFunctionBody _read_blockFunctionBody(LinkedNode data) { |
| return astFactory.blockFunctionBody( |
| _getToken(data.blockFunctionBody_keyword), |
| _getToken(data.blockFunctionBody_star), |
| readNode(data.blockFunctionBody_block), |
| ); |
| } |
| |
| BooleanLiteral _read_booleanLiteral(LinkedNode data) { |
| return astFactory.booleanLiteral( |
| _getToken(data.booleanLiteral_literal), |
| data.booleanLiteral_value, |
| )..staticType = _readType(data.expression_type); |
| } |
| |
| BreakStatement _read_breakStatement(LinkedNode data) { |
| return astFactory.breakStatement( |
| _getToken(data.breakStatement_breakKeyword), |
| readNode(data.breakStatement_label), |
| _getToken(data.breakStatement_semicolon), |
| ); |
| } |
| |
| CascadeExpression _read_cascadeExpression(LinkedNode data) { |
| return astFactory.cascadeExpression( |
| readNode(data.cascadeExpression_target), |
| _readNodeList(data.cascadeExpression_sections), |
| )..staticType = _readType(data.expression_type); |
| } |
| |
| CatchClause _read_catchClause(LinkedNode data) { |
| return astFactory.catchClause( |
| _getToken(data.catchClause_onKeyword), |
| readNode(data.catchClause_exceptionType), |
| _getToken(data.catchClause_catchKeyword), |
| _getToken(data.catchClause_leftParenthesis), |
| readNode(data.catchClause_exceptionParameter), |
| _getToken(data.catchClause_comma), |
| readNode(data.catchClause_stackTraceParameter), |
| _getToken(data.catchClause_rightParenthesis), |
| readNode(data.catchClause_body), |
| ); |
| } |
| |
| ClassDeclaration _read_classDeclaration(LinkedNode data) { |
| return astFactory.classDeclaration( |
| readNode(data.annotatedNode_comment), |
| _readNodeList(data.annotatedNode_metadata), |
| _getToken(data.classDeclaration_abstractKeyword), |
| _getToken(data.classDeclaration_classKeyword), |
| readNode(data.namedCompilationUnitMember_name), |
| readNode(data.classOrMixinDeclaration_typeParameters), |
| readNode(data.classDeclaration_extendsClause), |
| readNode(data.classDeclaration_withClause), |
| readNode(data.classOrMixinDeclaration_implementsClause), |
| _getToken(data.classOrMixinDeclaration_leftBracket), |
| _readNodeList(data.classOrMixinDeclaration_members), |
| _getToken(data.classOrMixinDeclaration_rightBracket), |
| ); |
| } |
| |
| ClassTypeAlias _read_classTypeAlias(LinkedNode data) { |
| return astFactory.classTypeAlias( |
| readNode(data.annotatedNode_comment), |
| _readNodeList(data.annotatedNode_metadata), |
| _getToken(data.typeAlias_typedefKeyword), |
| readNode(data.namedCompilationUnitMember_name), |
| readNode(data.classTypeAlias_typeParameters), |
| _getToken(data.classTypeAlias_equals), |
| _getToken(data.classTypeAlias_abstractKeyword), |
| readNode(data.classTypeAlias_superclass), |
| readNode(data.classTypeAlias_withClause), |
| readNode(data.classTypeAlias_implementsClause), |
| _getToken(data.typeAlias_semicolon), |
| ); |
| } |
| |
| Comment _read_comment(LinkedNode data) { |
| var tokens = _getTokens(data.comment_tokens); |
| switch (data.comment_type) { |
| case LinkedNodeCommentType.block: |
| return astFactory.endOfLineComment( |
| tokens, |
| ); |
| case LinkedNodeCommentType.documentation: |
| return astFactory.documentationComment( |
| tokens, |
| // TODO(scheglov) references |
| ); |
| case LinkedNodeCommentType.endOfLine: |
| return astFactory.endOfLineComment( |
| tokens, |
| ); |
| default: |
| throw StateError('${data.comment_type}'); |
| } |
| } |
| |
| CompilationUnit _read_compilationUnit(LinkedNode data) { |
| return astFactory.compilationUnit( |
| _getToken(data.compilationUnit_beginToken), |
| readNode(data.compilationUnit_scriptTag), |
| _readNodeList(data.compilationUnit_directives), |
| _readNodeList(data.compilationUnit_declarations), |
| _getToken(data.compilationUnit_endToken), |
| ); |
| } |
| |
| ConditionalExpression _read_conditionalExpression(LinkedNode data) { |
| return astFactory.conditionalExpression( |
| readNode(data.conditionalExpression_condition), |
| _getToken(data.conditionalExpression_question), |
| readNode(data.conditionalExpression_thenExpression), |
| _getToken(data.conditionalExpression_colon), |
| readNode(data.conditionalExpression_elseExpression), |
| )..staticType = _readType(data.expression_type); |
| } |
| |
| Configuration _read_configuration(LinkedNode data) { |
| return astFactory.configuration( |
| _getToken(data.configuration_ifKeyword), |
| _getToken(data.configuration_leftParenthesis), |
| readNode(data.configuration_name), |
| _getToken(data.configuration_equalToken), |
| readNode(data.configuration_value), |
| _getToken(data.configuration_rightParenthesis), |
| readNode(data.configuration_uri), |
| ); |
| } |
| |
| ConstructorDeclaration _read_constructorDeclaration(LinkedNode data) { |
| return astFactory.constructorDeclaration( |
| readNode(data.annotatedNode_comment), |
| _readNodeList(data.annotatedNode_metadata), |
| _getToken(data.constructorDeclaration_externalKeyword), |
| _getToken(data.constructorDeclaration_constKeyword), |
| _getToken(data.constructorDeclaration_factoryKeyword), |
| readNode(data.constructorDeclaration_returnType), |
| _getToken(data.constructorDeclaration_period), |
| readNode(data.constructorDeclaration_name), |
| readNode(data.constructorDeclaration_parameters), |
| _getToken(data.constructorDeclaration_separator), |
| _readNodeList(data.constructorDeclaration_initializers), |
| readNode(data.constructorDeclaration_redirectedConstructor), |
| readNode(data.constructorDeclaration_body), |
| ); |
| } |
| |
| ConstructorFieldInitializer _read_constructorFieldInitializer( |
| LinkedNode data) { |
| return astFactory.constructorFieldInitializer( |
| _getToken(data.constructorFieldInitializer_thisKeyword), |
| _getToken(data.constructorFieldInitializer_period), |
| readNode(data.constructorFieldInitializer_fieldName), |
| _getToken(data.constructorFieldInitializer_equals), |
| readNode(data.constructorFieldInitializer_expression), |
| ); |
| } |
| |
| ConstructorName _read_constructorName(LinkedNode data) { |
| return astFactory.constructorName( |
| readNode(data.constructorName_type), |
| _getToken(data.constructorName_period), |
| readNode(data.constructorName_name), |
| )..staticElement = _getElement(data.constructorName_element); |
| } |
| |
| ContinueStatement _read_continueStatement(LinkedNode data) { |
| return astFactory.continueStatement( |
| _getToken(data.continueStatement_continueKeyword), |
| readNode(data.continueStatement_label), |
| _getToken(data.continueStatement_semicolon), |
| ); |
| } |
| |
| DeclaredIdentifier _read_declaredIdentifier(LinkedNode data) { |
| return astFactory.declaredIdentifier( |
| readNode(data.annotatedNode_comment), |
| _readNodeList(data.annotatedNode_metadata), |
| _getToken(data.declaredIdentifier_keyword), |
| readNode(data.declaredIdentifier_type), |
| readNode(data.declaredIdentifier_identifier), |
| ); |
| } |
| |
| DefaultFormalParameter _read_defaultFormalParameter(LinkedNode data) { |
| return astFactory.defaultFormalParameter( |
| readNode(data.defaultFormalParameter_parameter), |
| data.defaultFormalParameter_isNamed |
| ? ParameterKind.NAMED |
| : ParameterKind.POSITIONAL, |
| _getToken(data.defaultFormalParameter_separator), |
| readNode(data.defaultFormalParameter_defaultValue), |
| ); |
| } |
| |
| DoStatement _read_doStatement(LinkedNode data) { |
| return astFactory.doStatement( |
| _getToken(data.doStatement_doKeyword), |
| readNode(data.doStatement_body), |
| _getToken(data.doStatement_whileKeyword), |
| _getToken(data.doStatement_leftParenthesis), |
| readNode(data.doStatement_condition), |
| _getToken(data.doStatement_rightParenthesis), |
| _getToken(data.doStatement_semicolon), |
| ); |
| } |
| |
| DottedName _read_dottedName(LinkedNode data) { |
| return astFactory.dottedName( |
| _readNodeList(data.dottedName_components), |
| ); |
| } |
| |
| DoubleLiteral _read_doubleLiteral(LinkedNode data) { |
| return astFactory.doubleLiteral( |
| _getToken(data.doubleLiteral_literal), |
| data.doubleLiteral_value, |
| )..staticType = _readType(data.expression_type); |
| } |
| |
| EmptyFunctionBody _read_emptyFunctionBody(LinkedNode data) { |
| return astFactory.emptyFunctionBody( |
| _getToken(data.emptyFunctionBody_semicolon), |
| ); |
| } |
| |
| EmptyStatement _read_emptyStatement(LinkedNode data) { |
| return astFactory.emptyStatement( |
| _getToken(data.emptyStatement_semicolon), |
| ); |
| } |
| |
| EnumConstantDeclaration _read_enumConstantDeclaration(LinkedNode data) { |
| return astFactory.enumConstantDeclaration( |
| readNode(data.annotatedNode_comment), |
| _readNodeList(data.annotatedNode_metadata), |
| readNode(data.enumConstantDeclaration_name), |
| ); |
| } |
| |
| EnumDeclaration _read_enumDeclaration(LinkedNode data) { |
| return astFactory.enumDeclaration( |
| readNode(data.annotatedNode_comment), |
| _readNodeList(data.annotatedNode_metadata), |
| _getToken(data.enumDeclaration_enumKeyword), |
| readNode(data.namedCompilationUnitMember_name), |
| _getToken(data.enumDeclaration_leftBracket), |
| _readNodeList(data.enumDeclaration_constants), |
| _getToken(data.enumDeclaration_rightBracket), |
| ); |
| } |
| |
| ExportDirective _read_exportDirective(LinkedNode data) { |
| return astFactory.exportDirective( |
| readNode(data.annotatedNode_comment), |
| _readNodeList(data.annotatedNode_metadata), |
| _getToken(data.directive_keyword), |
| readNode(data.uriBasedDirective_uri), |
| _readNodeList(data.namespaceDirective_configurations), |
| _readNodeList(data.namespaceDirective_combinators), |
| _getToken(data.namespaceDirective_semicolon), |
| ); |
| } |
| |
| ExpressionFunctionBody _read_expressionFunctionBody(LinkedNode data) { |
| return astFactory.expressionFunctionBody( |
| _getToken(data.expressionFunctionBody_keyword), |
| _getToken(data.expressionFunctionBody_arrow), |
| readNode(data.expressionFunctionBody_expression), |
| _getToken(data.expressionFunctionBody_semicolon), |
| ); |
| } |
| |
| ExpressionStatement _read_expressionStatement(LinkedNode data) { |
| return astFactory.expressionStatement( |
| readNode(data.expressionStatement_expression), |
| _getToken(data.expressionStatement_semicolon), |
| ); |
| } |
| |
| ExtendsClause _read_extendsClause(LinkedNode data) { |
| return astFactory.extendsClause( |
| _getToken(data.extendsClause_extendsKeyword), |
| readNode(data.extendsClause_superclass), |
| ); |
| } |
| |
| FieldDeclaration _read_fieldDeclaration(LinkedNode data) { |
| return astFactory.fieldDeclaration2( |
| comment: readNode(data.annotatedNode_comment), |
| covariantKeyword: _getToken(data.fieldDeclaration_covariantKeyword), |
| fieldList: readNode(data.fieldDeclaration_fields), |
| metadata: _readNodeList(data.annotatedNode_metadata), |
| semicolon: _getToken(data.fieldDeclaration_semicolon), |
| staticKeyword: _getToken(data.fieldDeclaration_staticKeyword), |
| ); |
| } |
| |
| FieldFormalParameter _read_fieldFormalParameter(LinkedNode data) { |
| return astFactory.fieldFormalParameter2( |
| identifier: readNode(data.normalFormalParameter_identifier), |
| period: _getToken(data.fieldFormalParameter_period), |
| thisKeyword: _getToken(data.fieldFormalParameter_thisKeyword), |
| covariantKeyword: _getToken(data.normalFormalParameter_covariantKeyword), |
| typeParameters: readNode(data.fieldFormalParameter_typeParameters), |
| keyword: _getToken(data.fieldFormalParameter_keyword), |
| metadata: _readNodeList(data.normalFormalParameter_metadata), |
| comment: readNode(data.normalFormalParameter_comment), |
| type: readNode(data.fieldFormalParameter_type), |
| parameters: readNode(data.fieldFormalParameter_formalParameters), |
| ); |
| } |
| |
| ForEachPartsWithDeclaration _read_forEachPartsWithDeclaration( |
| LinkedNode data) { |
| return astFactory.forEachPartsWithDeclaration( |
| inKeyword: _getToken(data.forEachParts_inKeyword), |
| iterable: readNode(data.forEachParts_iterable), |
| loopVariable: readNode(data.forEachPartsWithDeclaration_loopVariable), |
| ); |
| } |
| |
| ForEachPartsWithIdentifier _read_forEachPartsWithIdentifier(LinkedNode data) { |
| return astFactory.forEachPartsWithIdentifier( |
| inKeyword: _getToken(data.forEachParts_inKeyword), |
| iterable: readNode(data.forEachParts_iterable), |
| identifier: readNode(data.forEachPartsWithIdentifier_identifier), |
| ); |
| } |
| |
| ForElement _read_forElement(LinkedNode data) { |
| return astFactory.forElement( |
| awaitKeyword: _getToken(data.forMixin_awaitKeyword), |
| body: readNode(data.forElement_body), |
| forKeyword: _getToken(data.forMixin_forKeyword), |
| forLoopParts: readNode(data.forMixin_forLoopParts), |
| leftParenthesis: _getToken(data.forMixin_leftParenthesis), |
| rightParenthesis: _getToken(data.forMixin_rightParenthesis), |
| ); |
| } |
| |
| FormalParameterList _read_formalParameterList(LinkedNode data) { |
| return astFactory.formalParameterList( |
| _getToken(data.formalParameterList_leftParenthesis), |
| _readNodeList(data.formalParameterList_parameters), |
| _getToken(data.formalParameterList_leftDelimiter), |
| _getToken(data.formalParameterList_rightDelimiter), |
| _getToken(data.formalParameterList_rightParenthesis), |
| ); |
| } |
| |
| ForPartsWithDeclarations _read_forPartsWithDeclarations(LinkedNode data) { |
| return astFactory.forPartsWithDeclarations( |
| condition: readNode(data.forParts_condition), |
| leftSeparator: _getToken(data.forParts_leftSeparator), |
| rightSeparator: _getToken(data.forParts_rightSeparator), |
| updaters: _readNodeList(data.forParts_updaters), |
| variables: readNode(data.forPartsWithDeclarations_variables), |
| ); |
| } |
| |
| ForPartsWithExpression _read_forPartsWithExpression(LinkedNode data) { |
| return astFactory.forPartsWithExpression( |
| condition: readNode(data.forParts_condition), |
| initialization: readNode(data.forPartsWithExpression_initialization), |
| leftSeparator: _getToken(data.forParts_leftSeparator), |
| rightSeparator: _getToken(data.forParts_rightSeparator), |
| updaters: _readNodeList(data.forParts_updaters), |
| ); |
| } |
| |
| ForStatement2 _read_forStatement(LinkedNode data) { |
| return astFactory.forStatement2( |
| forKeyword: _getToken(data.forMixin_forKeyword), |
| leftParenthesis: _getToken(data.forMixin_leftParenthesis), |
| forLoopParts: readNode(data.forMixin_forLoopParts), |
| rightParenthesis: _getToken(data.forMixin_rightParenthesis), |
| body: readNode(data.forStatement_body), |
| ); |
| } |
| |
| FunctionDeclaration _read_functionDeclaration(LinkedNode data) { |
| return astFactory.functionDeclaration( |
| readNode(data.annotatedNode_comment), |
| _readNodeList(data.annotatedNode_metadata), |
| _getToken(data.functionDeclaration_externalKeyword), |
| readNode(data.functionDeclaration_returnType), |
| _getToken(data.functionDeclaration_propertyKeyword), |
| readNode(data.namedCompilationUnitMember_name), |
| readNode(data.functionDeclaration_functionExpression), |
| ); |
| } |
| |
| FunctionDeclarationStatement _read_functionDeclarationStatement( |
| LinkedNode data) { |
| return astFactory.functionDeclarationStatement( |
| readNode(data.functionDeclarationStatement_functionDeclaration), |
| ); |
| } |
| |
| FunctionExpression _read_functionExpression(LinkedNode data) { |
| return astFactory.functionExpression( |
| readNode(data.functionExpression_typeParameters), |
| readNode(data.functionExpression_formalParameters), |
| readNode(data.functionExpression_body), |
| ); |
| } |
| |
| FunctionExpressionInvocation _read_functionExpressionInvocation( |
| LinkedNode data) { |
| return astFactory.functionExpressionInvocation( |
| readNode(data.functionExpressionInvocation_function), |
| readNode(data.invocationExpression_typeArguments), |
| readNode(data.invocationExpression_arguments), |
| )..staticInvokeType = _readType(data.invocationExpression_invokeType); |
| } |
| |
| FunctionTypeAlias _read_functionTypeAlias(LinkedNode data) { |
| return astFactory.functionTypeAlias( |
| readNode(data.annotatedNode_comment), |
| _readNodeList(data.annotatedNode_metadata), |
| _getToken(data.typeAlias_typedefKeyword), |
| readNode(data.functionTypeAlias_returnType), |
| readNode(data.namedCompilationUnitMember_name), |
| readNode(data.functionTypeAlias_typeParameters), |
| readNode(data.functionTypeAlias_formalParameters), |
| _getToken(data.typeAlias_semicolon), |
| ); |
| } |
| |
| FunctionTypedFormalParameter _read_functionTypedFormalParameter( |
| LinkedNode data) { |
| return astFactory.functionTypedFormalParameter2( |
| identifier: readNode(data.normalFormalParameter_identifier), |
| parameters: readNode(data.functionTypedFormalParameter_formalParameters), |
| returnType: readNode(data.functionTypedFormalParameter_returnType), |
| covariantKeyword: _getToken(data.normalFormalParameter_covariantKeyword), |
| comment: readNode(data.normalFormalParameter_comment), |
| metadata: _readNodeList(data.normalFormalParameter_metadata), |
| typeParameters: |
| readNode(data.functionTypedFormalParameter_typeParameters), |
| ); |
| } |
| |
| GenericFunctionType _read_genericFunctionType(LinkedNode data) { |
| return astFactory.genericFunctionType( |
| readNode(data.genericFunctionType_returnType), |
| _getToken(data.genericFunctionType_functionKeyword), |
| readNode(data.genericFunctionType_typeParameters), |
| readNode(data.genericFunctionType_formalParameters), |
| question: _getToken(data.genericFunctionType_question), |
| ); |
| } |
| |
| GenericTypeAlias _read_genericTypeAlias(LinkedNode data) { |
| return astFactory.genericTypeAlias( |
| readNode(data.annotatedNode_comment), |
| _readNodeList(data.annotatedNode_metadata), |
| _getToken(data.typeAlias_typedefKeyword), |
| readNode(data.namedCompilationUnitMember_name), |
| readNode(data.genericTypeAlias_typeParameters), |
| _getToken(data.genericTypeAlias_equals), |
| readNode(data.genericTypeAlias_functionType), |
| _getToken(data.typeAlias_semicolon), |
| ); |
| } |
| |
| HideCombinator _read_hideCombinator(LinkedNode data) { |
| return astFactory.hideCombinator( |
| _getToken(data.combinator_keyword), |
| _readNodeList(data.hideCombinator_hiddenNames), |
| ); |
| } |
| |
| IfElement _read_ifElement(LinkedNode data) { |
| return astFactory.ifElement( |
| condition: readNode(data.ifMixin_condition), |
| elseElement: readNode(data.ifElement_elseElement), |
| elseKeyword: _getToken(data.ifMixin_elseKeyword), |
| ifKeyword: _getToken(data.ifMixin_ifKeyword), |
| leftParenthesis: _getToken(data.ifMixin_leftParenthesis), |
| rightParenthesis: _getToken(data.ifMixin_rightParenthesis), |
| thenElement: readNode(data.ifElement_thenElement), |
| ); |
| } |
| |
| IfStatement _read_ifStatement(LinkedNode data) { |
| return astFactory.ifStatement( |
| _getToken(data.ifMixin_ifKeyword), |
| _getToken(data.ifMixin_leftParenthesis), |
| readNode(data.ifMixin_condition), |
| _getToken(data.ifMixin_rightParenthesis), |
| readNode(data.ifStatement_thenStatement), |
| _getToken(data.ifMixin_elseKeyword), |
| readNode(data.ifStatement_elseStatement), |
| ); |
| } |
| |
| ImplementsClause _read_implementsClause(LinkedNode data) { |
| return astFactory.implementsClause( |
| _getToken(data.implementsClause_implementsKeyword), |
| _readNodeList(data.implementsClause_interfaces), |
| ); |
| } |
| |
| ImportDirective _read_importDirective(LinkedNode data) { |
| return astFactory.importDirective( |
| readNode(data.annotatedNode_comment), |
| _readNodeList(data.annotatedNode_metadata), |
| _getToken(data.directive_keyword), |
| readNode(data.uriBasedDirective_uri), |
| _readNodeList(data.namespaceDirective_configurations), |
| _getToken(data.importDirective_deferredKeyword), |
| _getToken(data.importDirective_asKeyword), |
| readNode(data.importDirective_prefix), |
| _readNodeList(data.namespaceDirective_combinators), |
| _getToken(data.namespaceDirective_semicolon), |
| ); |
| } |
| |
| IndexExpression _read_indexExpression(LinkedNode data) { |
| return astFactory.indexExpressionForTarget( |
| readNode(data.indexExpression_target), |
| _getToken(data.indexExpression_leftBracket), |
| readNode(data.indexExpression_index), |
| _getToken(data.indexExpression_rightBracket), |
| ) |
| ..staticElement = _getElement(data.indexExpression_element) |
| ..staticType = _readType(data.expression_type); |
| } |
| |
| InstanceCreationExpression _read_instanceCreationExpression(LinkedNode data) { |
| return astFactory.instanceCreationExpression( |
| _getToken(data.instanceCreationExpression_keyword), |
| readNode(data.instanceCreationExpression_constructorName), |
| readNode(data.instanceCreationExpression_arguments), |
| typeArguments: readNode(data.instanceCreationExpression_typeArguments), |
| )..staticType = _readType(data.expression_type); |
| } |
| |
| IntegerLiteral _read_integerLiteral(LinkedNode data) { |
| return astFactory.integerLiteral( |
| _getToken(data.integerLiteral_literal), |
| data.integerLiteral_value, |
| )..staticType = _readType(data.expression_type); |
| } |
| |
| InterpolationExpression _read_interpolationExpression(LinkedNode data) { |
| return astFactory.interpolationExpression( |
| _getToken(data.interpolationExpression_leftBracket), |
| readNode(data.interpolationExpression_expression), |
| _getToken(data.interpolationExpression_rightBracket), |
| ); |
| } |
| |
| InterpolationString _read_interpolationString(LinkedNode data) { |
| return astFactory.interpolationString( |
| _getToken(data.interpolationString_token), |
| data.interpolationString_value, |
| ); |
| } |
| |
| IsExpression _read_isExpression(LinkedNode data) { |
| return astFactory.isExpression( |
| readNode(data.isExpression_expression), |
| _getToken(data.isExpression_isOperator), |
| _getToken(data.isExpression_notOperator), |
| readNode(data.isExpression_type), |
| )..staticType = _readType(data.expression_type); |
| } |
| |
| Label _read_label(LinkedNode data) { |
| return astFactory.label( |
| readNode(data.label_label), |
| _getToken(data.label_colon), |
| ); |
| } |
| |
| LabeledStatement _read_labeledStatement(LinkedNode data) { |
| return astFactory.labeledStatement( |
| _readNodeList(data.labeledStatement_labels), |
| readNode(data.labeledStatement_statement), |
| ); |
| } |
| |
| LibraryDirective _read_libraryDirective(LinkedNode data) { |
| return astFactory.libraryDirective( |
| readNode(data.annotatedNode_comment), |
| _readNodeList(data.annotatedNode_metadata), |
| _getToken(data.directive_keyword), |
| readNode(data.libraryDirective_name), |
| _getToken(data.namespaceDirective_semicolon), |
| ); |
| } |
| |
| LibraryIdentifier _read_libraryIdentifier(LinkedNode data) { |
| return astFactory.libraryIdentifier( |
| _readNodeList(data.libraryIdentifier_components), |
| ); |
| } |
| |
| ListLiteral _read_listLiteral(LinkedNode data) { |
| return astFactory.listLiteral( |
| _getToken(data.typedLiteral_constKeyword), |
| readNode(data.typedLiteral_typeArguments), |
| _getToken(data.listLiteral_leftBracket), |
| _readNodeList(data.listLiteral_elements), |
| _getToken(data.listLiteral_rightBracket), |
| )..staticType = _readType(data.expression_type); |
| } |
| |
| MapLiteralEntry _read_mapLiteralEntry(LinkedNode data) { |
| return astFactory.mapLiteralEntry( |
| readNode(data.mapLiteralEntry_key), |
| _getToken(data.mapLiteralEntry_separator), |
| readNode(data.mapLiteralEntry_value), |
| ); |
| } |
| |
| MethodDeclaration _read_methodDeclaration(LinkedNode data) { |
| return astFactory.methodDeclaration( |
| readNode(data.annotatedNode_comment), |
| _readNodeList(data.annotatedNode_metadata), |
| _getToken(data.methodDeclaration_externalKeyword), |
| _getToken(data.methodDeclaration_modifierKeyword), |
| readNode(data.methodDeclaration_returnType), |
| _getToken(data.methodDeclaration_propertyKeyword), |
| _getToken(data.methodDeclaration_operatorKeyword), |
| readNode(data.methodDeclaration_name), |
| readNode(data.methodDeclaration_typeParameters), |
| readNode(data.methodDeclaration_formalParameters), |
| readNode(data.methodDeclaration_body), |
| ); |
| } |
| |
| MethodInvocation _read_methodInvocation(LinkedNode data) { |
| return astFactory.methodInvocation( |
| readNode(data.methodInvocation_target), |
| _getToken(data.methodInvocation_operator), |
| readNode(data.methodInvocation_methodName), |
| readNode(data.invocationExpression_typeArguments), |
| readNode(data.invocationExpression_arguments), |
| )..staticInvokeType = _readType(data.invocationExpression_invokeType); |
| } |
| |
| MixinDeclaration _read_mixinDeclaration(LinkedNode data) { |
| return astFactory.mixinDeclaration( |
| readNode(data.annotatedNode_comment), |
| _readNodeList(data.annotatedNode_metadata), |
| _getToken(data.mixinDeclaration_mixinKeyword), |
| readNode(data.namedCompilationUnitMember_name), |
| readNode(data.classOrMixinDeclaration_typeParameters), |
| readNode(data.mixinDeclaration_onClause), |
| readNode(data.classOrMixinDeclaration_implementsClause), |
| _getToken(data.classOrMixinDeclaration_leftBracket), |
| _readNodeList(data.classOrMixinDeclaration_members), |
| _getToken(data.classOrMixinDeclaration_rightBracket), |
| ); |
| } |
| |
| NamedExpression _read_namedExpression(LinkedNode data) { |
| return astFactory.namedExpression( |
| readNode(data.namedExpression_name), |
| readNode(data.namedExpression_expression), |
| )..staticType = _readType(data.expression_type); |
| } |
| |
| NullLiteral _read_nullLiteral(LinkedNode data) { |
| return astFactory.nullLiteral( |
| _getToken(data.nullLiteral_literal), |
| )..staticType = _readType(data.expression_type); |
| } |
| |
| OnClause _read_onClause(LinkedNode data) { |
| return astFactory.onClause( |
| _getToken(data.onClause_onKeyword), |
| _readNodeList(data.onClause_superclassConstraints), |
| ); |
| } |
| |
| ParenthesizedExpression _read_parenthesizedExpression(LinkedNode data) { |
| return astFactory.parenthesizedExpression( |
| _getToken(data.parenthesizedExpression_leftParenthesis), |
| readNode(data.parenthesizedExpression_expression), |
| _getToken(data.parenthesizedExpression_rightParenthesis), |
| )..staticType = _readType(data.expression_type); |
| } |
| |
| PartDirective _read_partDirective(LinkedNode data) { |
| return astFactory.partDirective( |
| readNode(data.annotatedNode_comment), |
| _readNodeList(data.annotatedNode_metadata), |
| _getToken(data.directive_keyword), |
| readNode(data.uriBasedDirective_uri), |
| _getToken(data.namespaceDirective_semicolon), |
| ); |
| } |
| |
| PartOfDirective _read_partOfDirective(LinkedNode data) { |
| return astFactory.partOfDirective( |
| readNode(data.annotatedNode_comment), |
| _readNodeList(data.annotatedNode_metadata), |
| _getToken(data.directive_keyword), |
| _getToken(data.partOfDirective_ofKeyword), |
| readNode(data.partOfDirective_uri), |
| readNode(data.partOfDirective_libraryName), |
| _getToken(data.partOfDirective_semicolon), |
| ); |
| } |
| |
| PostfixExpression _read_postfixExpression(LinkedNode data) { |
| return astFactory.postfixExpression( |
| readNode(data.postfixExpression_operand), |
| _getToken(data.postfixExpression_operator), |
| ) |
| ..staticElement = _getElement(data.postfixExpression_element) |
| ..staticType = _readType(data.expression_type); |
| } |
| |
| PrefixedIdentifier _read_prefixedIdentifier(LinkedNode data) { |
| return astFactory.prefixedIdentifier( |
| readNode(data.prefixedIdentifier_prefix), |
| _getToken(data.prefixedIdentifier_period), |
| readNode(data.prefixedIdentifier_identifier), |
| )..staticType = _readType(data.expression_type); |
| } |
| |
| PrefixExpression _read_prefixExpression(LinkedNode data) { |
| return astFactory.prefixExpression( |
| _getToken(data.prefixExpression_operator), |
| readNode(data.prefixExpression_operand), |
| ) |
| ..staticElement = _getElement(data.prefixExpression_element) |
| ..staticType = _readType(data.expression_type); |
| } |
| |
| PropertyAccess _read_propertyAccess(LinkedNode data) { |
| return astFactory.propertyAccess( |
| readNode(data.propertyAccess_target), |
| _getToken(data.propertyAccess_operator), |
| readNode(data.propertyAccess_propertyName), |
| )..staticType = _readType(data.expression_type); |
| } |
| |
| RedirectingConstructorInvocation _read_redirectingConstructorInvocation( |
| LinkedNode data) { |
| return astFactory.redirectingConstructorInvocation( |
| _getToken(data.redirectingConstructorInvocation_thisKeyword), |
| _getToken(data.redirectingConstructorInvocation_period), |
| readNode(data.redirectingConstructorInvocation_constructorName), |
| readNode(data.redirectingConstructorInvocation_arguments), |
| )..staticElement = |
| _getElement(data.redirectingConstructorInvocation_element); |
| } |
| |
| RethrowExpression _read_rethrowExpression(LinkedNode data) { |
| return astFactory.rethrowExpression( |
| _getToken(data.rethrowExpression_rethrowKeyword), |
| )..staticType = _readType(data.expression_type); |
| } |
| |
| ReturnStatement _read_returnStatement(LinkedNode data) { |
| return astFactory.returnStatement( |
| _getToken(data.returnStatement_returnKeyword), |
| readNode(data.returnStatement_expression), |
| _getToken(data.returnStatement_semicolon), |
| ); |
| } |
| |
| ScriptTag _read_scriptTag(LinkedNode data) { |
| return astFactory.scriptTag( |
| _getToken(data.scriptTag_scriptTag), |
| ); |
| } |
| |
| SetOrMapLiteral _read_setOrMapLiteral(LinkedNode data) { |
| SetOrMapLiteralImpl node = astFactory.setOrMapLiteral( |
| constKeyword: _getToken(data.typedLiteral_constKeyword), |
| elements: _readNodeList(data.setOrMapLiteral_elements), |
| leftBracket: _getToken(data.setOrMapLiteral_leftBracket), |
| typeArguments: readNode(data.typedLiteral_typeArguments), |
| rightBracket: _getToken(data.setOrMapLiteral_leftBracket), |
| ); |
| if (data.setOrMapLiteral_isMap) { |
| node.becomeMap(); |
| } else if (data.setOrMapLiteral_isSet) { |
| node.becomeSet(); |
| } |
| return node; |
| } |
| |
| ShowCombinator _read_showCombinator(LinkedNode data) { |
| return astFactory.showCombinator( |
| _getToken(data.combinator_keyword), |
| _readNodeList(data.showCombinator_shownNames), |
| ); |
| } |
| |
| SimpleFormalParameter _read_simpleFormalParameter(LinkedNode data) { |
| return astFactory.simpleFormalParameter2( |
| identifier: readNode(data.normalFormalParameter_identifier), |
| type: readNode(data.simpleFormalParameter_type), |
| covariantKeyword: _getToken(data.normalFormalParameter_covariantKeyword), |
| comment: readNode(data.normalFormalParameter_comment), |
| metadata: _readNodeList(data.normalFormalParameter_metadata), |
| keyword: _getToken(data.simpleFormalParameter_keyword), |
| ); |
| } |
| |
| SimpleIdentifier _read_simpleIdentifier(LinkedNode data) { |
| return astFactory.simpleIdentifier( |
| _getToken(data.simpleIdentifier_token), |
| ) |
| ..staticElement = _getElement(data.simpleIdentifier_element) |
| ..staticType = _readType(data.expression_type); |
| } |
| |
| SimpleStringLiteral _read_simpleStringLiteral(LinkedNode data) { |
| return astFactory.simpleStringLiteral( |
| _getToken(data.simpleStringLiteral_token), |
| data.simpleStringLiteral_value, |
| )..staticType = _readType(data.expression_type); |
| } |
| |
| SpreadElement _read_spreadElement(LinkedNode data) { |
| return astFactory.spreadElement( |
| spreadOperator: _getToken(data.spreadElement_spreadOperator), |
| expression: readNode(data.spreadElement_expression), |
| ); |
| } |
| |
| StringInterpolation _read_stringInterpolation(LinkedNode data) { |
| return astFactory.stringInterpolation( |
| _readNodeList(data.stringInterpolation_elements), |
| )..staticType = _readType(data.expression_type); |
| } |
| |
| SuperConstructorInvocation _read_superConstructorInvocation(LinkedNode data) { |
| return astFactory.superConstructorInvocation( |
| _getToken(data.superConstructorInvocation_superKeyword), |
| _getToken(data.superConstructorInvocation_period), |
| readNode(data.superConstructorInvocation_constructorName), |
| readNode(data.superConstructorInvocation_arguments), |
| )..staticElement = _getElement(data.superConstructorInvocation_element); |
| } |
| |
| SuperExpression _read_superExpression(LinkedNode data) { |
| return astFactory.superExpression( |
| _getToken(data.superExpression_superKeyword), |
| )..staticType = _readType(data.expression_type); |
| } |
| |
| SwitchCase _read_switchCase(LinkedNode data) { |
| return astFactory.switchCase( |
| _readNodeList(data.switchMember_labels), |
| _getToken(data.switchMember_keyword), |
| readNode(data.switchCase_expression), |
| _getToken(data.switchMember_colon), |
| _readNodeList(data.switchMember_statements), |
| ); |
| } |
| |
| SwitchDefault _read_switchDefault(LinkedNode data) { |
| return astFactory.switchDefault( |
| _readNodeList(data.switchMember_labels), |
| _getToken(data.switchMember_keyword), |
| _getToken(data.switchMember_colon), |
| _readNodeList(data.switchMember_statements), |
| ); |
| } |
| |
| SwitchStatement _read_switchStatement(LinkedNode data) { |
| return astFactory.switchStatement( |
| _getToken(data.switchStatement_switchKeyword), |
| _getToken(data.switchStatement_leftParenthesis), |
| readNode(data.switchStatement_expression), |
| _getToken(data.switchStatement_rightParenthesis), |
| _getToken(data.switchStatement_leftBracket), |
| _readNodeList(data.switchStatement_members), |
| _getToken(data.switchStatement_rightBracket), |
| ); |
| } |
| |
| SymbolLiteral _read_symbolLiteral(LinkedNode data) { |
| return astFactory.symbolLiteral( |
| _getToken(data.symbolLiteral_poundSign), |
| _getTokens(data.symbolLiteral_components), |
| )..staticType = _readType(data.expression_type); |
| } |
| |
| ThisExpression _read_thisExpression(LinkedNode data) { |
| return astFactory.thisExpression( |
| _getToken(data.thisExpression_thisKeyword), |
| )..staticType = _readType(data.expression_type); |
| } |
| |
| ThrowExpression _read_throwExpression(LinkedNode data) { |
| return astFactory.throwExpression( |
| _getToken(data.throwExpression_throwKeyword), |
| readNode(data.throwExpression_expression), |
| )..staticType = _readType(data.expression_type); |
| } |
| |
| TopLevelVariableDeclaration _read_topLevelVariableDeclaration( |
| LinkedNode data) { |
| return astFactory.topLevelVariableDeclaration( |
| readNode(data.annotatedNode_comment), |
| _readNodeList(data.annotatedNode_metadata), |
| readNode(data.topLevelVariableDeclaration_variableList), |
| _getToken(data.topLevelVariableDeclaration_semicolon), |
| ); |
| } |
| |
| TryStatement _read_tryStatement(LinkedNode data) { |
| return astFactory.tryStatement( |
| _getToken(data.tryStatement_tryKeyword), |
| readNode(data.tryStatement_body), |
| _readNodeList(data.tryStatement_catchClauses), |
| _getToken(data.tryStatement_tryKeyword), |
| readNode(data.tryStatement_finallyBlock), |
| ); |
| } |
| |
| TypeArgumentList _read_typeArgumentList(LinkedNode data) { |
| return astFactory.typeArgumentList( |
| _getToken(data.typeArgumentList_leftBracket), |
| _readNodeList(data.typeArgumentList_arguments), |
| _getToken(data.typeArgumentList_rightBracket), |
| ); |
| } |
| |
| TypeName _read_typeName(LinkedNode data) { |
| return astFactory.typeName( |
| readNode(data.typeName_name), |
| readNode(data.typeName_typeArguments), |
| question: _getToken(data.typeName_question), |
| )..type = _readType(data.typeName_type); |
| } |
| |
| TypeParameter _read_typeParameter(LinkedNode data) { |
| return astFactory.typeParameter( |
| readNode(data.annotatedNode_comment), |
| _readNodeList(data.annotatedNode_metadata), |
| readNode(data.typeParameter_name), |
| _getToken(data.typeParameter_extendsKeyword), |
| readNode(data.typeParameter_bound), |
| ); |
| } |
| |
| TypeParameterList _read_typeParameterList(LinkedNode data) { |
| return astFactory.typeParameterList( |
| _getToken(data.typeParameterList_leftBracket), |
| _readNodeList(data.typeParameterList_typeParameters), |
| _getToken(data.typeParameterList_rightBracket), |
| ); |
| } |
| |
| VariableDeclaration _read_variableDeclaration(LinkedNode data) { |
| return astFactory.variableDeclaration( |
| readNode(data.variableDeclaration_name), |
| _getToken(data.variableDeclaration_equals), |
| readNode(data.variableDeclaration_initializer), |
| ); |
| } |
| |
| VariableDeclarationList _read_variableDeclarationList(LinkedNode data) { |
| return astFactory.variableDeclarationList( |
| readNode(data.annotatedNode_comment), |
| _readNodeList(data.annotatedNode_metadata), |
| _getToken(data.variableDeclarationList_keyword), |
| readNode(data.variableDeclarationList_type), |
| _readNodeList(data.variableDeclarationList_variables), |
| ); |
| } |
| |
| VariableDeclarationStatement _read_variableDeclarationStatement( |
| LinkedNode data) { |
| return astFactory.variableDeclarationStatement( |
| readNode(data.variableDeclarationStatement_variables), |
| _getToken(data.variableDeclarationStatement_semicolon), |
| ); |
| } |
| |
| WhileStatement _read_whileStatement(LinkedNode data) { |
| return astFactory.whileStatement( |
| _getToken(data.whileStatement_whileKeyword), |
| _getToken(data.whileStatement_leftParenthesis), |
| readNode(data.whileStatement_condition), |
| _getToken(data.whileStatement_rightParenthesis), |
| readNode(data.whileStatement_body), |
| ); |
| } |
| |
| WithClause _read_withClause(LinkedNode data) { |
| return astFactory.withClause( |
| _getToken(data.withClause_withKeyword), |
| _readNodeList(data.withClause_mixinTypes), |
| ); |
| } |
| |
| YieldStatement _read_yieldStatement(LinkedNode data) { |
| return astFactory.yieldStatement( |
| _getToken(data.yieldStatement_yieldKeyword), |
| _getToken(data.yieldStatement_star), |
| readNode(data.yieldStatement_expression), |
| _getToken(data.yieldStatement_semicolon), |
| ); |
| } |
| |
| List<T> _readNodeList<T>(List<LinkedNode> nodeList) { |
| var result = List<T>.filled(nodeList.length, null); |
| for (var i = 0; i < nodeList.length; ++i) { |
| var linkedNode = nodeList[i]; |
| result[i] = readNode(linkedNode) as T; |
| } |
| return result; |
| } |
| |
| DartType _readType(LinkedNodeType data) { |
| if (data == null) return null; |
| |
| switch (data.kind) { |
| case LinkedNodeTypeKind.bottom: |
| return BottomTypeImpl.instance; |
| case LinkedNodeTypeKind.dynamic_: |
| return DynamicTypeImpl.instance; |
| case LinkedNodeTypeKind.function: |
| return FunctionTypeImpl.synthetic( |
| _readType(data.functionReturnType), |
| _getElements(data.functionTypeParameters), |
| _getElements(data.functionFormalParameters), |
| ); |
| case LinkedNodeTypeKind.interface: |
| var element = _getElement(data.interfaceClass); |
| if (element != null) { |
| return InterfaceTypeImpl.explicit( |
| element, |
| _readTypes( |
| data.interfaceTypeArguments, |
| const <InterfaceType>[], |
| ), |
| ); |
| } |
| return DynamicTypeImpl.instance; |
| case LinkedNodeTypeKind.typeParameter: |
| var element = _getElement(data.typeParameterParameter); |
| // TODO(scheglov) Remove when references include all type parameters. |
| element ??= TypeParameterElementImpl('', -1); |
| return TypeParameterTypeImpl(element); |
| case LinkedNodeTypeKind.void_: |
| return VoidTypeImpl.instance; |
| default: |
| throw UnimplementedError('Type kind: ${data.kind}'); |
| } |
| } |
| |
| List<T> _readTypes<T extends DartType>( |
| List<LinkedNodeType> dataList, |
| List<T> ifEmpty, |
| ) { |
| if (dataList.isEmpty) return ifEmpty; |
| |
| var result = List<T>(dataList.length); |
| for (var i = 0; i < dataList.length; ++i) { |
| var data = dataList[i]; |
| result[i] = _readType(data); |
| } |
| return result; |
| } |
| |
| static TokenType _binaryToAstTokenType(UnlinkedTokenType type) { |
| switch (type) { |
| case UnlinkedTokenType.ABSTRACT: |
| return Keyword.ABSTRACT; |
| case UnlinkedTokenType.AMPERSAND: |
| return TokenType.AMPERSAND; |
| case UnlinkedTokenType.AMPERSAND_AMPERSAND: |
| return TokenType.AMPERSAND_AMPERSAND; |
| case UnlinkedTokenType.AMPERSAND_EQ: |
| return TokenType.AMPERSAND_EQ; |
| case UnlinkedTokenType.AS: |
| return TokenType.AS; |
| case UnlinkedTokenType.ASSERT: |
| return Keyword.ASSERT; |
| case UnlinkedTokenType.ASYNC: |
| return Keyword.ASYNC; |
| case UnlinkedTokenType.AT: |
| return TokenType.AT; |
| case UnlinkedTokenType.AWAIT: |
| return Keyword.AWAIT; |
| case UnlinkedTokenType.BACKPING: |
| return TokenType.BACKPING; |
| case UnlinkedTokenType.BACKSLASH: |
| return TokenType.BACKSLASH; |
| case UnlinkedTokenType.BANG: |
| return TokenType.BANG; |
| case UnlinkedTokenType.BANG_EQ: |
| return TokenType.BANG_EQ; |
| case UnlinkedTokenType.BAR: |
| return TokenType.BAR; |
| case UnlinkedTokenType.BAR_BAR: |
| return TokenType.BAR_BAR; |
| case UnlinkedTokenType.BAR_EQ: |
| return TokenType.BAR_EQ; |
| case UnlinkedTokenType.BREAK: |
| return Keyword.BREAK; |
| case UnlinkedTokenType.CARET: |
| return TokenType.CARET; |
| case UnlinkedTokenType.CARET_EQ: |
| return TokenType.CARET_EQ; |
| case UnlinkedTokenType.CASE: |
| return Keyword.CASE; |
| case UnlinkedTokenType.CATCH: |
| return Keyword.CATCH; |
| case UnlinkedTokenType.CLASS: |
| return Keyword.CLASS; |
| case UnlinkedTokenType.CLOSE_CURLY_BRACKET: |
| return TokenType.CLOSE_CURLY_BRACKET; |
| case UnlinkedTokenType.CLOSE_PAREN: |
| return TokenType.CLOSE_PAREN; |
| case UnlinkedTokenType.CLOSE_SQUARE_BRACKET: |
| return TokenType.CLOSE_SQUARE_BRACKET; |
| case UnlinkedTokenType.COLON: |
| return TokenType.COLON; |
| case UnlinkedTokenType.COMMA: |
| return TokenType.COMMA; |
| case UnlinkedTokenType.CONST: |
| return Keyword.CONST; |
| case UnlinkedTokenType.CONTINUE: |
| return Keyword.CONTINUE; |
| case UnlinkedTokenType.COVARIANT: |
| return Keyword.COVARIANT; |
| case UnlinkedTokenType.DEFAULT: |
| return Keyword.DEFAULT; |
| case UnlinkedTokenType.DEFERRED: |
| return Keyword.DEFERRED; |
| case UnlinkedTokenType.DO: |
| return Keyword.DO; |
| case UnlinkedTokenType.DOUBLE: |
| return TokenType.DOUBLE; |
| case UnlinkedTokenType.DYNAMIC: |
| return Keyword.DYNAMIC; |
| case UnlinkedTokenType.ELSE: |
| return Keyword.ELSE; |
| case UnlinkedTokenType.ENUM: |
| return Keyword.ENUM; |
| case UnlinkedTokenType.EOF: |
| return TokenType.EOF; |
| case UnlinkedTokenType.EQ: |
| return TokenType.EQ; |
| case UnlinkedTokenType.EQ_EQ: |
| return TokenType.EQ_EQ; |
| case UnlinkedTokenType.EXPORT: |
| return Keyword.EXPORT; |
| case UnlinkedTokenType.EXTENDS: |
| return Keyword.EXTENDS; |
| case UnlinkedTokenType.EXTERNAL: |
| return Keyword.EXTERNAL; |
| case UnlinkedTokenType.FACTORY: |
| return Keyword.FACTORY; |
| case UnlinkedTokenType.FALSE: |
| return Keyword.FALSE; |
| case UnlinkedTokenType.FINAL: |
| return Keyword.FINAL; |
| case UnlinkedTokenType.FINALLY: |
| return Keyword.FINALLY; |
| case UnlinkedTokenType.FOR: |
| return Keyword.FOR; |
| case UnlinkedTokenType.FUNCTION: |
| return TokenType.FUNCTION; |
| case UnlinkedTokenType.FUNCTION_KEYWORD: |
| return Keyword.FUNCTION; |
| case UnlinkedTokenType.GET: |
| return Keyword.GET; |
| case UnlinkedTokenType.GT: |
| return TokenType.GT; |
| case UnlinkedTokenType.GT_EQ: |
| return TokenType.GT_EQ; |
| case UnlinkedTokenType.GT_GT: |
| return TokenType.GT_GT; |
| case UnlinkedTokenType.GT_GT_EQ: |
| return TokenType.GT_GT_EQ; |
| case UnlinkedTokenType.HASH: |
| return TokenType.HASH; |
| case UnlinkedTokenType.HEXADECIMAL: |
| return TokenType.HEXADECIMAL; |
| case UnlinkedTokenType.HIDE: |
| return Keyword.HIDE; |
| case UnlinkedTokenType.IDENTIFIER: |
| return TokenType.IDENTIFIER; |
| case UnlinkedTokenType.IF: |
| return Keyword.IF; |
| case UnlinkedTokenType.IMPLEMENTS: |
| return Keyword.IMPLEMENTS; |
| case UnlinkedTokenType.IMPORT: |
| return Keyword.IMPORT; |
| case UnlinkedTokenType.IN: |
| return Keyword.IN; |
| case UnlinkedTokenType.INDEX: |
| return TokenType.INDEX; |
| case UnlinkedTokenType.INDEX_EQ: |
| return TokenType.INDEX_EQ; |
| case UnlinkedTokenType.INT: |
| return TokenType.INT; |
| case UnlinkedTokenType.INTERFACE: |
| return Keyword.INTERFACE; |
| case UnlinkedTokenType.IS: |
| return TokenType.IS; |
| case UnlinkedTokenType.LIBRARY: |
| return Keyword.LIBRARY; |
| case UnlinkedTokenType.LT: |
| return TokenType.LT; |
| case UnlinkedTokenType.LT_EQ: |
| return TokenType.LT_EQ; |
| case UnlinkedTokenType.LT_LT: |
| return TokenType.LT_LT; |
| case UnlinkedTokenType.LT_LT_EQ: |
| return TokenType.LT_LT_EQ; |
| case UnlinkedTokenType.MINUS: |
| return TokenType.MINUS; |
| case UnlinkedTokenType.MINUS_EQ: |
| return TokenType.MINUS_EQ; |
| case UnlinkedTokenType.MINUS_MINUS: |
| return TokenType.MINUS_MINUS; |
| case UnlinkedTokenType.MIXIN: |
| return Keyword.MIXIN; |
| case UnlinkedTokenType.MULTI_LINE_COMMENT: |
| return TokenType.MULTI_LINE_COMMENT; |
| case UnlinkedTokenType.NATIVE: |
| return Keyword.NATIVE; |
| case UnlinkedTokenType.NEW: |
| return Keyword.NEW; |
| case UnlinkedTokenType.NULL: |
| return Keyword.NULL; |
| case UnlinkedTokenType.OF: |
| return Keyword.OF; |
| case UnlinkedTokenType.ON: |
| return Keyword.ON; |
| case UnlinkedTokenType.OPEN_CURLY_BRACKET: |
| return TokenType.OPEN_CURLY_BRACKET; |
| case UnlinkedTokenType.OPEN_PAREN: |
| return TokenType.OPEN_PAREN; |
| case UnlinkedTokenType.OPEN_SQUARE_BRACKET: |
| return TokenType.OPEN_SQUARE_BRACKET; |
| case UnlinkedTokenType.OPERATOR: |
| return Keyword.OPERATOR; |
| case UnlinkedTokenType.PART: |
| return Keyword.PART; |
| case UnlinkedTokenType.PATCH: |
| return Keyword.PATCH; |
| case UnlinkedTokenType.PERCENT: |
| return TokenType.PERCENT; |
| case UnlinkedTokenType.PERCENT_EQ: |
| return TokenType.PERCENT_EQ; |
| case UnlinkedTokenType.PERIOD: |
| return TokenType.PERIOD; |
| case UnlinkedTokenType.PERIOD_PERIOD: |
| return TokenType.PERIOD_PERIOD; |
| case UnlinkedTokenType.PERIOD_PERIOD_PERIOD: |
| return TokenType.PERIOD_PERIOD_PERIOD; |
| case UnlinkedTokenType.PERIOD_PERIOD_PERIOD_QUESTION: |
| return TokenType.PERIOD_PERIOD_PERIOD_QUESTION; |
| case UnlinkedTokenType.PLUS: |
| return TokenType.PLUS; |
| case UnlinkedTokenType.PLUS_EQ: |
| return TokenType.PLUS_EQ; |
| case UnlinkedTokenType.PLUS_PLUS: |
| return TokenType.PLUS_PLUS; |
| case UnlinkedTokenType.QUESTION: |
| return TokenType.QUESTION; |
| case UnlinkedTokenType.QUESTION_PERIOD: |
| return TokenType.QUESTION_PERIOD; |
| case UnlinkedTokenType.QUESTION_QUESTION: |
| return TokenType.QUESTION_QUESTION; |
| case UnlinkedTokenType.QUESTION_QUESTION_EQ: |
| return TokenType.QUESTION_QUESTION_EQ; |
| case UnlinkedTokenType.RETHROW: |
| return Keyword.RETHROW; |
| case UnlinkedTokenType.RETURN: |
| return Keyword.RETURN; |
| case UnlinkedTokenType.SCRIPT_TAG: |
| return TokenType.SCRIPT_TAG; |
| case UnlinkedTokenType.SEMICOLON: |
| return TokenType.SEMICOLON; |
| case UnlinkedTokenType.SET: |
| return Keyword.SET; |
| case UnlinkedTokenType.SHOW: |
| return Keyword.SHOW; |
| case UnlinkedTokenType.SINGLE_LINE_COMMENT: |
| return TokenType.SINGLE_LINE_COMMENT; |
| case UnlinkedTokenType.SLASH: |
| return TokenType.SLASH; |
| case UnlinkedTokenType.SLASH_EQ: |
| return TokenType.SLASH_EQ; |
| case UnlinkedTokenType.SOURCE: |
| return Keyword.SOURCE; |
| case UnlinkedTokenType.STAR: |
| return TokenType.STAR; |
| case UnlinkedTokenType.STAR_EQ: |
| return TokenType.STAR_EQ; |
| case UnlinkedTokenType.STATIC: |
| return Keyword.STATIC; |
| case UnlinkedTokenType.STRING: |
| return TokenType.STRING; |
| case UnlinkedTokenType.STRING_INTERPOLATION_EXPRESSION: |
| return TokenType.STRING_INTERPOLATION_EXPRESSION; |
| case UnlinkedTokenType.STRING_INTERPOLATION_IDENTIFIER: |
| return TokenType.STRING_INTERPOLATION_IDENTIFIER; |
| case UnlinkedTokenType.SUPER: |
| return Keyword.SUPER; |
| case UnlinkedTokenType.SWITCH: |
| return Keyword.SWITCH; |
| case UnlinkedTokenType.SYNC: |
| return Keyword.SYNC; |
| case UnlinkedTokenType.THIS: |
| return Keyword.THIS; |
| case UnlinkedTokenType.THROW: |
| return Keyword.THROW; |
| case UnlinkedTokenType.TILDE: |
| return TokenType.TILDE; |
| case UnlinkedTokenType.TILDE_SLASH: |
| return TokenType.TILDE_SLASH; |
| case UnlinkedTokenType.TILDE_SLASH_EQ: |
| return TokenType.TILDE_SLASH_EQ; |
| case UnlinkedTokenType.TRUE: |
| return Keyword.TRUE; |
| case UnlinkedTokenType.TRY: |
| return Keyword.TRY; |
| case UnlinkedTokenType.TYPEDEF: |
| return Keyword.TYPEDEF; |
| case UnlinkedTokenType.VAR: |
| return Keyword.VAR; |
| case UnlinkedTokenType.VOID: |
| return Keyword.VOID; |
| case UnlinkedTokenType.WHILE: |
| return Keyword.WHILE; |
| case UnlinkedTokenType.WITH: |
| return Keyword.WITH; |
| case UnlinkedTokenType.YIELD: |
| return Keyword.YIELD; |
| default: |
| throw StateError('Unexpected type: $type'); |
| } |
| } |
| } |
