| // Copyright (c) 2017, 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. |
| |
| // @dart = 2.9 |
| |
| import 'package:_fe_analyzer_shared/src/scanner/scanner.dart'; |
| import 'package:_fe_analyzer_shared/src/scanner/abstract_scanner.dart' |
| show AbstractScanner; |
| import 'package:_fe_analyzer_shared/src/scanner/token_impl.dart' as fasta; |
| import 'package:_fe_analyzer_shared/src/scanner/token.dart'; |
| import 'package:test/test.dart'; |
| import 'package:test_reflective_loader/test_reflective_loader.dart'; |
| |
| main() { |
| defineReflectiveSuite(() { |
| defineReflectiveTests(PrecedenceInfoTest); |
| }); |
| } |
| |
| /// Assert that fasta PrecedenceInfo implements analyzer TokenType. |
| @reflectiveTest |
| class PrecedenceInfoTest { |
| void assertInfo(check(String source, Token token)) { |
| void assertLexeme(String source) { |
| if (source == null || source.isEmpty) return; |
| var token = scanString(source, includeComments: true).tokens; |
| while (token is ErrorToken) { |
| token = token.next; |
| } |
| check(source, token); |
| } |
| |
| for (TokenType type in TokenType.all) { |
| assertLexeme(type.lexeme); |
| } |
| assertLexeme('1.0'); // DOUBLE |
| assertLexeme('0xA'); // HEXADECIMAL |
| assertLexeme('1'); // INT |
| assertLexeme('var'); // KEYWORD |
| assertLexeme('#!/'); // SCRIPT_TAG |
| assertLexeme('"foo"'); // STRING |
| assertLexeme('bar'); // IDENTIFIER |
| if (AbstractScanner.LAZY_ASSIGNMENT_ENABLED) { |
| assertLexeme('&&='); |
| assertLexeme('||='); |
| } |
| } |
| |
| void test_isOperator() { |
| var operatorLexemes = new Set<String>.from(const [ |
| '&', |
| '&&', |
| '&&=', |
| '&=', |
| '!', |
| '!=', |
| '|', |
| '||', |
| '||=', |
| '|=', |
| '^', |
| '^=', |
| '=', |
| '==', |
| '>', |
| '>=', |
| '>>', |
| '>>=', |
| '[]', |
| '[]=', |
| '<', |
| '<=', |
| '<<', |
| '<<=', |
| '-', |
| '-=', |
| '--', |
| '%', |
| '%=', |
| '..', |
| '+', |
| '+=', |
| '++', |
| '?', |
| '?.', |
| '??', |
| '??=', |
| '/', |
| '/=', |
| '*', |
| '*=', |
| '~', |
| '~/', |
| '~/=', |
| ]); |
| |
| assertInfo((String source, Token token) { |
| expect(token.isOperator, operatorLexemes.contains(source), |
| reason: source); |
| expect(token.type.isOperator, operatorLexemes.contains(source), |
| reason: source); |
| }); |
| } |
| |
| void test_isAdditiveOperator() { |
| var additiveLexemes = [ |
| '-', |
| '+', |
| ]; |
| assertInfo((String source, Token token) { |
| expect(token.type.isAdditiveOperator, additiveLexemes.contains(source), |
| reason: source); |
| }); |
| } |
| |
| void test_isAssignmentOperator() { |
| const assignmentLexemes = const [ |
| '&=', |
| '&&=', |
| '|=', |
| '||=', |
| '^=', |
| '=', |
| '>>=', |
| '<<=', |
| '-=', |
| '%=', |
| '+=', |
| '??=', |
| '/=', |
| '*=', |
| '~/=', |
| ]; |
| assertInfo((String source, Token token) { |
| expect( |
| token.type.isAssignmentOperator, assignmentLexemes.contains(source), |
| reason: source); |
| }); |
| } |
| |
| void test_isAssociativeOperator() { |
| const associativeLexemes = const [ |
| '&', |
| '&&', |
| '|', |
| '||', |
| '^', |
| '+', |
| '*', |
| ]; |
| assertInfo((String source, Token token) { |
| expect( |
| token.type.isAssociativeOperator, associativeLexemes.contains(source), |
| reason: source); |
| }); |
| } |
| |
| void test_isEqualityOperator() { |
| const equalityLexemes = const [ |
| '!=', |
| '==', |
| ]; |
| assertInfo((String source, Token token) { |
| expect(token.type.isEqualityOperator, equalityLexemes.contains(source), |
| reason: source); |
| }); |
| } |
| |
| void test_isIncrementOperator() { |
| const incrementLexemes = const [ |
| '--', |
| '++', |
| ]; |
| assertInfo((String source, Token token) { |
| expect(token.type.isIncrementOperator, incrementLexemes.contains(source), |
| reason: source); |
| }); |
| } |
| |
| void test_isMultiplicativeOperator() { |
| const multiplicativeLexemes = const [ |
| '%', |
| '/', |
| '*', |
| '~/', |
| ]; |
| assertInfo((String source, Token token) { |
| expect(token.type.isMultiplicativeOperator, |
| multiplicativeLexemes.contains(source), |
| reason: source); |
| }); |
| } |
| |
| void test_isRelationalOperator() { |
| const relationalLexemes = const [ |
| '>', |
| '>=', |
| '<', |
| '<=', |
| ]; |
| assertInfo((String source, Token token) { |
| expect( |
| token.type.isRelationalOperator, relationalLexemes.contains(source), |
| reason: source); |
| }); |
| } |
| |
| void test_isShiftOperator() { |
| const shiftLexemes = const [ |
| '>>', |
| '<<', |
| ]; |
| assertInfo((String source, Token token) { |
| expect(token.type.isShiftOperator, shiftLexemes.contains(source), |
| reason: source); |
| }); |
| } |
| |
| void test_isUnaryPostfixOperator() { |
| const unaryPostfixLexemes = const [ |
| '--', |
| '++', |
| ]; |
| assertInfo((String source, Token token) { |
| expect(token.type.isUnaryPostfixOperator, |
| unaryPostfixLexemes.contains(source), |
| reason: source); |
| }); |
| } |
| |
| void test_isUnaryPrefixOperator() { |
| const unaryPrefixLexemes = const [ |
| '!', |
| '-', |
| '--', |
| '++', |
| '~', |
| ]; |
| assertInfo((String source, Token token) { |
| expect( |
| token.type.isUnaryPrefixOperator, unaryPrefixLexemes.contains(source), |
| reason: source); |
| }); |
| } |
| |
| void test_isSelectorOperator() { |
| const selectorLexemes = const [ |
| '(', |
| '[', |
| '.', |
| '?.', |
| '[]', |
| ]; |
| assertInfo((String source, Token token) { |
| expect(token.type.isSelectorOperator, selectorLexemes.contains(source), |
| reason: source); |
| }); |
| } |
| |
| void test_isUserDefinableOperator() { |
| const userDefinableOperatorLexemes = const [ |
| '&', |
| '|', |
| '^', |
| '==', |
| '>', |
| '>=', |
| '>>', |
| '[]', |
| '[]=', |
| '<', |
| '<=', |
| '<<', |
| '-', |
| '%', |
| '+', |
| '/', |
| '*', |
| '~', |
| '~/', |
| ]; |
| assertInfo((String source, Token token) { |
| var userDefinable = userDefinableOperatorLexemes.contains(source); |
| expect(token.type.isUserDefinableOperator, userDefinable, reason: source); |
| expect(token.isUserDefinableOperator, userDefinable, reason: source); |
| expect(fasta.isUserDefinableOperator(token.lexeme), userDefinable, |
| reason: source); |
| }); |
| } |
| |
| void test_name() { |
| void assertName(String source, String name, {int offset: 0}) { |
| if (source == null || source.isEmpty) return; |
| var token = scanString(source, includeComments: true).tokens; |
| while (token is ErrorToken || token.offset < offset) { |
| token = token.next; |
| } |
| expect(token.type.name, name, |
| reason: 'source: $source\ntoken: ${token.lexeme}'); |
| } |
| |
| assertName('&', 'AMPERSAND'); |
| assertName('&&', 'AMPERSAND_AMPERSAND'); |
| assertName('&=', 'AMPERSAND_EQ'); |
| assertName('@', 'AT'); |
| assertName('!', 'BANG'); |
| assertName('!=', 'BANG_EQ'); |
| assertName('|', 'BAR'); |
| assertName('||', 'BAR_BAR'); |
| assertName('|=', 'BAR_EQ'); |
| assertName(':', 'COLON'); |
| assertName(',', 'COMMA'); |
| assertName('^', 'CARET'); |
| assertName('^=', 'CARET_EQ'); |
| assertName('}', 'CLOSE_CURLY_BRACKET'); |
| assertName(')', 'CLOSE_PAREN'); |
| assertName(']', 'CLOSE_SQUARE_BRACKET'); |
| assertName('=', 'EQ'); |
| assertName('==', 'EQ_EQ'); |
| assertName('=>', 'FUNCTION'); |
| assertName('>', 'GT'); |
| assertName('>=', 'GT_EQ'); |
| assertName('>>', 'GT_GT'); |
| assertName('>>=', 'GT_GT_EQ'); |
| assertName('#', 'HASH'); |
| assertName('[]', 'INDEX'); |
| assertName('[]=', 'INDEX_EQ'); |
| assertName('<', 'LT'); |
| assertName('<=', 'LT_EQ'); |
| assertName('<<', 'LT_LT'); |
| assertName('<<=', 'LT_LT_EQ'); |
| assertName('-', 'MINUS'); |
| assertName('-=', 'MINUS_EQ'); |
| assertName('--', 'MINUS_MINUS'); |
| assertName('{', 'OPEN_CURLY_BRACKET'); |
| assertName('(', 'OPEN_PAREN'); |
| assertName('[', 'OPEN_SQUARE_BRACKET'); |
| assertName('%', 'PERCENT'); |
| assertName('%=', 'PERCENT_EQ'); |
| assertName('.', 'PERIOD'); |
| assertName('..', 'PERIOD_PERIOD'); |
| assertName('+', 'PLUS'); |
| assertName('+=', 'PLUS_EQ'); |
| assertName('++', 'PLUS_PLUS'); |
| assertName('?', 'QUESTION'); |
| assertName('?.', 'QUESTION_PERIOD'); |
| assertName('??', 'QUESTION_QUESTION'); |
| assertName('??=', 'QUESTION_QUESTION_EQ'); |
| assertName(';', 'SEMICOLON'); |
| assertName('/', 'SLASH'); |
| assertName('/=', 'SLASH_EQ'); |
| assertName('*', 'STAR'); |
| assertName('*=', 'STAR_EQ'); |
| assertName('"\${', 'STRING_INTERPOLATION_EXPRESSION', offset: 1); |
| assertName('"\$', 'STRING_INTERPOLATION_IDENTIFIER', offset: 1); |
| assertName('~', 'TILDE'); |
| assertName('~/', 'TILDE_SLASH'); |
| assertName('~/=', 'TILDE_SLASH_EQ'); |
| assertName('`', 'BACKPING'); |
| assertName('\\', 'BACKSLASH'); |
| assertName('...', 'PERIOD_PERIOD_PERIOD'); |
| assertName('...?', 'PERIOD_PERIOD_PERIOD_QUESTION'); |
| } |
| |
| /// Assert precedence as per the Dart language spec |
| /// |
| /// Prefix "++" and "--" are excluded from the prefix (15) list |
| /// because they are interpreted as being in the postfix (16) list. |
| /// Leading "-" is excluded from the precedence 15 list |
| /// because it is interpreted as a minus token (precedence 13). |
| void test_precedence() { |
| const precedenceTable = const <int, List<String>>{ |
| 17: const <String>['.', '?.', '[', '('], |
| 16: const <String>['++', '--'], |
| 15: const <String>['!', '~'], // excluded '-', '++', '--' |
| 14: const <String>['*', '/', '~/', '%'], |
| 13: const <String>['+', '-'], |
| 12: const <String>['<<', '>>'], |
| 11: const <String>['&'], |
| 10: const <String>['^'], |
| 9: const <String>['|'], |
| 8: const <String>['<', '>', '<=', '>=', 'as', 'is', 'is!'], |
| 7: const <String>['==', '!='], |
| 6: const <String>['&&'], |
| 5: const <String>['||'], |
| 4: const <String>['??'], |
| 3: const <String>['? :'], |
| 2: const <String>['..'], |
| 1: const <String>['=', '*=', '/=', '+=', '-=', '&=', '^='], |
| }; |
| precedenceTable.forEach((precedence, lexemes) { |
| for (String source in lexemes) { |
| var token = scanString(source, includeComments: true).tokens; |
| while (token is ErrorToken) { |
| token = token.next; |
| } |
| expect(token.type.precedence, precedence, reason: source); |
| } |
| }); |
| } |
| |
| void test_type() { |
| void assertLexeme(String source, TokenType tt) { |
| var token = scanString(source, includeComments: true).tokens; |
| expect(token.type, same(tt), reason: source); |
| } |
| |
| assertLexeme('1.0', TokenType.DOUBLE); |
| assertLexeme('0xA', TokenType.HEXADECIMAL); |
| assertLexeme('1', TokenType.INT); |
| assertLexeme('var', Keyword.VAR); |
| assertLexeme('#!/', TokenType.SCRIPT_TAG); |
| assertLexeme('foo', TokenType.IDENTIFIER); |
| assertLexeme('"foo"', TokenType.STRING); |
| } |
| } |