New analyzer snapshot.

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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.parser_test;
 
 import 'package:analyzer/src/generated/java_core.dart';
@@ skipping 3803 matching lines @@
   }
 
   void test_logicalOrExpression_precedence_logicalAnd_right() {
     BinaryExpression expression = ParserTestCase.parseExpression("|| &&", [
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER]);
     EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.rightOperand);
   }
 
+  void test_missingGet() {
+    CompilationUnit unit = ParserTestCase.parseCompilationUnit(EngineTestCase.createSource(["class C {", "  int length {}", "  void foo() {}", "}"]), [ParserErrorCode.MISSING_GET]);
+    JUnitTestCase.assertNotNull(unit);
+    ClassDeclaration classDeclaration = unit.declarations[0] as ClassDeclaration;
+    NodeList<ClassMember> members = classDeclaration.members;
+    EngineTestCase.assertSizeOfList(2, members);
+    EngineTestCase.assertInstanceOf((obj) => obj is MethodDeclaration, MethodDeclaration, members[0]);
+    ClassMember member = members[1];
+    EngineTestCase.assertInstanceOf((obj) => obj is MethodDeclaration, MethodDeclaration, member);
+    JUnitTestCase.assertEquals("foo", (member as MethodDeclaration).name.name);
+  }
+
   void test_missingIdentifier_afterAnnotation() {
     MethodDeclaration method = ParserTestCase.parse3("parseClassMember", <Object> ["C"], "@override }", [ParserErrorCode.EXPECTED_CLASS_MEMBER]);
     JUnitTestCase.assertNull(method.documentationComment);
     NodeList<Annotation> metadata = method.metadata;
     EngineTestCase.assertSizeOfList(1, metadata);
     JUnitTestCase.assertEquals("override", metadata[0].name.name);
   }
 
   void test_multiplicativeExpression_missing_LHS() {
     BinaryExpression expression = ParserTestCase.parseExpression("* y", [ParserErrorCode.MISSING_IDENTIFIER]);
@@ skipping 41 matching lines @@
     EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.leftOperand);
   }
 
   void test_prefixExpression_missing_operand_minus() {
     PrefixExpression expression = ParserTestCase.parseExpression("-", [ParserErrorCode.MISSING_IDENTIFIER]);
     EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.operand);
     JUnitTestCase.assertTrue(expression.operand.isSynthetic);
     JUnitTestCase.assertEquals(TokenType.MINUS, expression.operator.type);
   }
 
+  void test_primaryExpression_argumentDefinitionTest() {
+    Expression expression = ParserTestCase.parse4("parsePrimaryExpression", "?a", [ParserErrorCode.UNEXPECTED_TOKEN]);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression);
+  }
+
   void test_relationalExpression_missing_LHS() {
     IsExpression expression = ParserTestCase.parseExpression("is y", [ParserErrorCode.MISSING_IDENTIFIER]);
     EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.expression);
     JUnitTestCase.assertTrue(expression.expression.isSynthetic);
   }
 
   void test_relationalExpression_missing_LHS_RHS() {
     IsExpression expression = ParserTestCase.parseExpression("is", [
         ParserErrorCode.EXPECTED_TYPE_NAME,
         ParserErrorCode.MISSING_IDENTIFIER]);
@@ skipping 309 matching lines @@
         runJUnitTest(__test, __test.test_logicalOrExpression_missing_RHS);
       });
       _ut.test('test_logicalOrExpression_precedence_logicalAnd_left', () {
         final __test = new RecoveryParserTest();
         runJUnitTest(__test, __test.test_logicalOrExpression_precedence_logicalAnd_left);
       });
       _ut.test('test_logicalOrExpression_precedence_logicalAnd_right', () {
         final __test = new RecoveryParserTest();
         runJUnitTest(__test, __test.test_logicalOrExpression_precedence_logicalAnd_right);
       });
+      _ut.test('test_missingGet', () {
+        final __test = new RecoveryParserTest();
+        runJUnitTest(__test, __test.test_missingGet);
+      });
       _ut.test('test_missingIdentifier_afterAnnotation', () {
         final __test = new RecoveryParserTest();
         runJUnitTest(__test, __test.test_missingIdentifier_afterAnnotation);
       });
       _ut.test('test_multiplicativeExpression_missing_LHS', () {
         final __test = new RecoveryParserTest();
         runJUnitTest(__test, __test.test_multiplicativeExpression_missing_LHS);
       });
       _ut.test('test_multiplicativeExpression_missing_LHS_RHS', () {
         final __test = new RecoveryParserTest();
@@ skipping 16 matching lines @@
         runJUnitTest(__test, __test.test_multiplicativeExpression_precedence_unary_right);
       });
       _ut.test('test_multiplicativeExpression_super', () {
         final __test = new RecoveryParserTest();
         runJUnitTest(__test, __test.test_multiplicativeExpression_super);
       });
       _ut.test('test_prefixExpression_missing_operand_minus', () {
         final __test = new RecoveryParserTest();
         runJUnitTest(__test, __test.test_prefixExpression_missing_operand_minus);
       });
+      _ut.test('test_primaryExpression_argumentDefinitionTest', () {
+        final __test = new RecoveryParserTest();
+        runJUnitTest(__test, __test.test_primaryExpression_argumentDefinitionTest);
+      });
       _ut.test('test_relationalExpression_missing_LHS', () {
         final __test = new RecoveryParserTest();
         runJUnitTest(__test, __test.test_relationalExpression_missing_LHS);
       });
       _ut.test('test_relationalExpression_missing_LHS_RHS', () {
         final __test = new RecoveryParserTest();
         runJUnitTest(__test, __test.test_relationalExpression_missing_LHS_RHS);
       });
       _ut.test('test_relationalExpression_missing_RHS', () {
         final __test = new RecoveryParserTest();
@@ skipping 43 matching lines @@
   void test_visitAnnotation() {
     String annotationName = "proxy";
     Annotation fromNode = AstFactory.annotation(AstFactory.identifier3(annotationName));
     Element element = ElementFactory.topLevelVariableElement2(annotationName);
     fromNode.element = element;
     Annotation toNode = AstFactory.annotation(AstFactory.identifier3(annotationName));
     ResolutionCopier.copyResolutionData(fromNode, toNode);
     JUnitTestCase.assertSame(element, toNode.element);
   }
 
-  void test_visitArgumentDefinitionTest() {
-    String identifier = "p";
-    ArgumentDefinitionTest fromNode = AstFactory.argumentDefinitionTest(identifier);
-    DartType propagatedType = ElementFactory.classElement2("A", []).type;
-    fromNode.propagatedType = propagatedType;
-    DartType staticType = ElementFactory.classElement2("B", []).type;
-    fromNode.staticType = staticType;
-    ArgumentDefinitionTest toNode = AstFactory.argumentDefinitionTest(identifier);
-    ResolutionCopier.copyResolutionData(fromNode, toNode);
-    JUnitTestCase.assertSame(propagatedType, toNode.propagatedType);
-    JUnitTestCase.assertSame(staticType, toNode.staticType);
-  }
-
   void test_visitAsExpression() {
     AsExpression fromNode = AstFactory.asExpression(AstFactory.identifier3("x"), AstFactory.typeName4("A", []));
     DartType propagatedType = ElementFactory.classElement2("A", []).type;
     fromNode.propagatedType = propagatedType;
     DartType staticType = ElementFactory.classElement2("B", []).type;
     fromNode.staticType = staticType;
     AsExpression toNode = AstFactory.asExpression(AstFactory.identifier3("x"), AstFactory.typeName4("A", []));
     ResolutionCopier.copyResolutionData(fromNode, toNode);
     JUnitTestCase.assertSame(propagatedType, toNode.propagatedType);
     JUnitTestCase.assertSame(staticType, toNode.staticType);
@@ skipping 148 matching lines @@
     fromNode.staticType = staticType;
     FunctionExpressionInvocation toNode = AstFactory.functionExpressionInvocation(AstFactory.identifier3("f"), []);
     ResolutionCopier.copyResolutionData(fromNode, toNode);
     JUnitTestCase.assertSame(propagatedElement, toNode.propagatedElement);
     JUnitTestCase.assertSame(propagatedType, toNode.propagatedType);
     JUnitTestCase.assertSame(staticElement, toNode.staticElement);
     JUnitTestCase.assertSame(staticType, toNode.staticType);
   }
 
   void test_visitImportDirective() {
-    ImportDirective fromNode = AstFactory.importDirective2("dart:uri", null, []);
+    ImportDirective fromNode = AstFactory.importDirective3("dart:uri", null, []);
     ImportElement element = new ImportElementImpl(0);
     fromNode.element = element;
-    ImportDirective toNode = AstFactory.importDirective2("dart:uri", null, []);
+    ImportDirective toNode = AstFactory.importDirective3("dart:uri", null, []);
     ResolutionCopier.copyResolutionData(fromNode, toNode);
     JUnitTestCase.assertSame(element, toNode.element);
   }
 
   void test_visitIndexExpression() {
     IndexExpression fromNode = AstFactory.indexExpression(AstFactory.identifier3("a"), AstFactory.integer(0));
     MethodElement propagatedElement = ElementFactory.methodElement("m", ElementFactory.classElement2("C", []).type, []);
     MethodElement staticElement = ElementFactory.methodElement("m", ElementFactory.classElement2("C", []).type, []);
     AuxiliaryElements auxiliaryElements = new AuxiliaryElements(staticElement, propagatedElement);
     fromNode.auxiliaryElements = auxiliaryElements;
@@ skipping 345 matching lines @@
     ResolutionCopier.copyResolutionData(fromNode, toNode);
     JUnitTestCase.assertSame(type, toNode.type);
   }
 
   static dartSuite() {
     _ut.group('ResolutionCopierTest', () {
       _ut.test('test_visitAnnotation', () {
         final __test = new ResolutionCopierTest();
         runJUnitTest(__test, __test.test_visitAnnotation);
       });
-      _ut.test('test_visitArgumentDefinitionTest', () {
-        final __test = new ResolutionCopierTest();
-        runJUnitTest(__test, __test.test_visitArgumentDefinitionTest);
-      });
       _ut.test('test_visitAsExpression', () {
         final __test = new ResolutionCopierTest();
         runJUnitTest(__test, __test.test_visitAsExpression);
       });
       _ut.test('test_visitAssignmentExpression', () {
         final __test = new ResolutionCopierTest();
         runJUnitTest(__test, __test.test_visitAssignmentExpression);
       });
       _ut.test('test_visitBinaryExpression', () {
         final __test = new ResolutionCopierTest();
@@ skipping 538 matching lines @@
     JUnitTestCase.assertNotNull(name.colon);
     JUnitTestCase.assertNotNull(expression.expression);
   }
 
   void test_parseArgument_unnamed() {
     String lexeme = "x";
     SimpleIdentifier identifier = ParserTestCase.parse4("parseArgument", lexeme, []);
     JUnitTestCase.assertEquals(lexeme, identifier.name);
   }
 
-  void test_parseArgumentDefinitionTest() {
-    ArgumentDefinitionTest test = ParserTestCase.parse4("parseArgumentDefinitionTest", "?x", [ParserErrorCode.DEPRECATED_ARGUMENT_DEFINITION_TEST]);
-    JUnitTestCase.assertNotNull(test.question);
-    JUnitTestCase.assertNotNull(test.identifier);
-  }
-
   void test_parseArgumentList_empty() {
     ArgumentList argumentList = ParserTestCase.parse4("parseArgumentList", "()", []);
     NodeList<Expression> arguments = argumentList.arguments;
     EngineTestCase.assertSizeOfList(0, arguments);
   }
 
   void test_parseArgumentList_mixed() {
     ArgumentList argumentList = ParserTestCase.parse4("parseArgumentList", "(w, x, y: y, z: z)", []);
     NodeList<Expression> arguments = argumentList.arguments;
     EngineTestCase.assertSizeOfList(4, arguments);
@@ skipping 4575 matching lines @@
         runJUnitTest(__test, __test.test_parseAnnotation_n2_a);
       });
       _ut.test('test_parseAnnotation_n3', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseAnnotation_n3);
       });
       _ut.test('test_parseAnnotation_n3_a', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseAnnotation_n3_a);
       });
-      _ut.test('test_parseArgumentDefinitionTest', () {
-        final __test = new SimpleParserTest();
-        runJUnitTest(__test, __test.test_parseArgumentDefinitionTest);
-      });
       _ut.test('test_parseArgumentList_empty', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseArgumentList_empty);
       });
       _ut.test('test_parseArgumentList_mixed', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseArgumentList_mixed);
       });
       _ut.test('test_parseArgumentList_noNamed', () {
         final __test = new SimpleParserTest();
@@ skipping 1921 matching lines @@
 
 main() {
   ComplexParserTest.dartSuite();
   ErrorParserTest.dartSuite();
   IncrementalParserTest.dartSuite();
   NonErrorParserTest.dartSuite();
   RecoveryParserTest.dartSuite();
   ResolutionCopierTest.dartSuite();
   SimpleParserTest.dartSuite();
 }