Pull the 'keyword' property into Token.

pkg/analyzer/test/generated/parser_test.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library analyzer.test.generated.parser_test;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/src/dart/ast/token.dart';
@@ skipping 3681 matching lines @@
     CompilationUnitMember unitMember = declarations[0];
     EngineTestCase.assertInstanceOf(
         (obj) => obj is ClassDeclaration, ClassDeclaration, unitMember);
     NodeList<ClassMember> members = (unitMember as ClassDeclaration).members;
     expect(members, hasLength(1));
     ClassMember classMember = members[0];
     EngineTestCase.assertInstanceOf(
         (obj) => obj is FieldDeclaration, FieldDeclaration, classMember);
     VariableDeclarationList fieldList =
         (classMember as FieldDeclaration).fields;
-    expect((fieldList.keyword as KeywordToken).keyword, Keyword.CONST);
+    expect(fieldList.keyword.keyword, Keyword.CONST);
     NodeList<VariableDeclaration> fields = fieldList.variables;
     expect(fields, hasLength(1));
     VariableDeclaration field = fields[0];
     expect(field.name.isSynthetic, isTrue);
   }
 
   void test_incompleteField_final() {
     CompilationUnit unit = ParserTestCase.parseCompilationUnit(
         r'''
 class C {
   final
 }''',
         [ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.EXPECTED_TOKEN]);
     NodeList<CompilationUnitMember> declarations = unit.declarations;
     expect(declarations, hasLength(1));
     CompilationUnitMember unitMember = declarations[0];
     EngineTestCase.assertInstanceOf(
         (obj) => obj is ClassDeclaration, ClassDeclaration, unitMember);
     NodeList<ClassMember> members = (unitMember as ClassDeclaration).members;
     expect(members, hasLength(1));
     ClassMember classMember = members[0];
     EngineTestCase.assertInstanceOf(
         (obj) => obj is FieldDeclaration, FieldDeclaration, classMember);
     VariableDeclarationList fieldList =
         (classMember as FieldDeclaration).fields;
-    expect((fieldList.keyword as KeywordToken).keyword, Keyword.FINAL);
+    expect(fieldList.keyword.keyword, Keyword.FINAL);
     NodeList<VariableDeclaration> fields = fieldList.variables;
     expect(fields, hasLength(1));
     VariableDeclaration field = fields[0];
     expect(field.name.isSynthetic, isTrue);
   }
 
   void test_incompleteField_var() {
     CompilationUnit unit = ParserTestCase.parseCompilationUnit(
         r'''
 class C {
   var
 }''',
         [ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.EXPECTED_TOKEN]);
     NodeList<CompilationUnitMember> declarations = unit.declarations;
     expect(declarations, hasLength(1));
     CompilationUnitMember unitMember = declarations[0];
     EngineTestCase.assertInstanceOf(
         (obj) => obj is ClassDeclaration, ClassDeclaration, unitMember);
     NodeList<ClassMember> members = (unitMember as ClassDeclaration).members;
     expect(members, hasLength(1));
     ClassMember classMember = members[0];
     EngineTestCase.assertInstanceOf(
         (obj) => obj is FieldDeclaration, FieldDeclaration, classMember);
     VariableDeclarationList fieldList =
         (classMember as FieldDeclaration).fields;
-    expect((fieldList.keyword as KeywordToken).keyword, Keyword.VAR);
+    expect(fieldList.keyword.keyword, Keyword.VAR);
     NodeList<VariableDeclaration> fields = fieldList.variables;
     expect(fields, hasLength(1));
     VariableDeclaration field = fields[0];
     expect(field.name.isSynthetic, isTrue);
   }
 
   void test_incompleteForEach() {
     ForStatement statement = ParserTestCase.parseStatement(
         'for (String item i) {}',
         [ParserErrorCode.EXPECTED_TOKEN, ParserErrorCode.EXPECTED_TOKEN]);
@@ skipping 3733 matching lines @@
     EngineTestCase.assertInstanceOf(
         (obj) => obj is TypeName, TypeName, clause.superclass);
   }
 
   void test_parseFinalConstVarOrType_const_noType() {
     FinalConstVarOrType result =
         parse("parseFinalConstVarOrType", <Object>[false], "const");
     Token keyword = result.keyword;
     expect(keyword, isNotNull);
     expect(keyword.type, TokenType.KEYWORD);
-    expect((keyword as KeywordToken).keyword, Keyword.CONST);
+    expect(keyword.keyword, Keyword.CONST);
     expect(result.type, isNull);
   }
 
   void test_parseFinalConstVarOrType_const_type() {
     FinalConstVarOrType result =
         parse("parseFinalConstVarOrType", <Object>[false], "const A a");
     Token keyword = result.keyword;
     expect(keyword, isNotNull);
     expect(keyword.type, TokenType.KEYWORD);
-    expect((keyword as KeywordToken).keyword, Keyword.CONST);
+    expect(keyword.keyword, Keyword.CONST);
     expect(result.type, isNotNull);
   }
 
   void test_parseFinalConstVarOrType_final_noType() {
     FinalConstVarOrType result =
         parse("parseFinalConstVarOrType", <Object>[false], "final");
     Token keyword = result.keyword;
     expect(keyword, isNotNull);
     expect(keyword.type, TokenType.KEYWORD);
-    expect((keyword as KeywordToken).keyword, Keyword.FINAL);
+    expect(keyword.keyword, Keyword.FINAL);
     expect(result.type, isNull);
   }
 
   void test_parseFinalConstVarOrType_final_prefixedType() {
     FinalConstVarOrType result =
         parse("parseFinalConstVarOrType", <Object>[false], "final p.A a");
     Token keyword = result.keyword;
     expect(keyword, isNotNull);
     expect(keyword.type, TokenType.KEYWORD);
-    expect((keyword as KeywordToken).keyword, Keyword.FINAL);
+    expect(keyword.keyword, Keyword.FINAL);
     expect(result.type, isNotNull);
   }
 
   void test_parseFinalConstVarOrType_final_type() {
     FinalConstVarOrType result =
         parse("parseFinalConstVarOrType", <Object>[false], "final A a");
     Token keyword = result.keyword;
     expect(keyword, isNotNull);
     expect(keyword.type, TokenType.KEYWORD);
-    expect((keyword as KeywordToken).keyword, Keyword.FINAL);
+    expect(keyword.keyword, Keyword.FINAL);
     expect(result.type, isNotNull);
   }
 
   void test_parseFinalConstVarOrType_type_parameterized() {
     FinalConstVarOrType result =
         parse("parseFinalConstVarOrType", <Object>[false], "A<B> a");
     expect(result.keyword, isNull);
     expect(result.type, isNotNull);
   }
 
@@ skipping 24 matching lines @@
     expect(result.keyword, isNull);
     expect(result.type, isNotNull);
   }
 
   void test_parseFinalConstVarOrType_var() {
     FinalConstVarOrType result =
         parse("parseFinalConstVarOrType", <Object>[false], "var");
     Token keyword = result.keyword;
     expect(keyword, isNotNull);
     expect(keyword.type, TokenType.KEYWORD);
-    expect((keyword as KeywordToken).keyword, Keyword.VAR);
+    expect(keyword.keyword, Keyword.VAR);
     expect(result.type, isNull);
   }
 
   void test_parseFinalConstVarOrType_void() {
     FinalConstVarOrType result =
         parse("parseFinalConstVarOrType", <Object>[false], "void f()");
     expect(result.keyword, isNull);
     expect(result.type, isNotNull);
   }
 
@@ skipping 3569 matching lines @@
         new Scanner(null, new CharSequenceReader(source), listener);
     Token tokenStream = scanner.tokenize();
     //
     // Parse the source.
     //
     Parser parser = new Parser(null, listener);
     return invokeParserMethodImpl(
         parser, methodName, <Object>[tokenStream], tokenStream) as Token;
   }
 }