Constant top-level variables should not have setters.

pkg/analyzer/test/generated/all_the_rest_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.all_the_rest_test;
 
 import 'dart:collection';
@@ skipping 2383 matching lines @@
     expect(cache.setContents(source, contents), contents);
     expect(cache.setContents(source, null), contents);
     expect(cache.getContents(source), isNull);
     expect(cache.getModificationStamp(source), isNull);
     expect(cache.setContents(source, null), isNull);
   }
 }
 
 
 @reflectiveTest
+class CustomUriResolverTest {
+  void test_creation() {
+    expect(new CustomUriResolver({}), isNotNull);
+  }
+
+  void test_resolve_unknown_uri() {
+    UriResolver resolver = new CustomUriResolver({
+      'custom:library': '/path/to/library.dart',
+    });
+    Source result = resolver.resolveAbsolute(
+        parseUriWithException("custom:non_library"));
+    expect(result, isNull);
+  }
+
+  void test_resolve_uri() {
+    String path =
+        FileUtilities2.createFile("/path/to/library.dart").getAbsolutePath();
+    UriResolver resolver = new CustomUriResolver({
+      'custom:library': path,
+    });
+    Source result = resolver.resolveAbsolute(
+        parseUriWithException("custom:library"));
+    expect(result, isNotNull);
+    expect(result.fullName, path);
+  }
+}
+
+
+@reflectiveTest
 class DartObjectImplTest extends EngineTestCase {
   TypeProvider _typeProvider = new TestTypeProvider();
 
   void fail_add_knownString_knownString() {
     fail("New constant semantics are not yet enabled");
     _assertAdd(_stringValue("ab"), _stringValue("a"), _stringValue("b"));
   }
 
   void fail_add_knownString_unknownString() {
     fail("New constant semantics are not yet enabled");
@@ skipping 3748 matching lines @@
     expect(variable, isNotNull);
     expect(variable.initializer, isNull);
     expect(variable.name, variableName);
     expect(variable.isConst, isFalse);
     expect(variable.isFinal, isFalse);
     expect(variable.isSynthetic, isFalse);
     expect(variable.getter, isNotNull);
     expect(variable.setter, isNotNull);
   }
 
+  void test_visitVariableDeclaration_top_const_hasInitializer() {
+    ElementHolder holder = new ElementHolder();
+    ElementBuilder builder = new ElementBuilder(holder);
+    String variableName = "v";
+    VariableDeclaration variableDeclaration =
+        AstFactory.variableDeclaration2(variableName, AstFactory.integer(42));
+    AstFactory.variableDeclarationList2(Keyword.CONST, [variableDeclaration]);
+    variableDeclaration.accept(builder);
+    List<TopLevelVariableElement> variables = holder.topLevelVariables;
+    expect(variables, hasLength(1));
+    TopLevelVariableElement variable = variables[0];
+    expect(variable, new isInstanceOf<ConstTopLevelVariableElementImpl>());
+    expect(variable.initializer, isNotNull);
+    expect(variable.name, variableName);
+    expect(variable.isConst, isTrue);
+    expect(variable.isFinal, isFalse);
+    expect(variable.isSynthetic, isFalse);
+    expect(variable.getter, isNotNull);
+    expect(variable.setter, isNull);
+  }
+
+  void test_visitVariableDeclaration_top_final() {
+    ElementHolder holder = new ElementHolder();
+    ElementBuilder builder = new ElementBuilder(holder);
+    String variableName = "v";
+    VariableDeclaration variableDeclaration =
+        AstFactory.variableDeclaration2(variableName, null);
+    AstFactory.variableDeclarationList2(Keyword.FINAL, [variableDeclaration]);
+    variableDeclaration.accept(builder);
+    List<TopLevelVariableElement> variables = holder.topLevelVariables;
+    expect(variables, hasLength(1));
+    TopLevelVariableElement variable = variables[0];
+    expect(variable, isNotNull);
+    expect(variable.initializer, isNull);
+    expect(variable.name, variableName);
+    expect(variable.isConst, isFalse);
+    expect(variable.isFinal, isTrue);
+    expect(variable.isSynthetic, isFalse);
+    expect(variable.getter, isNotNull);
+    expect(variable.setter, isNull);
+  }
+
   void _useParameterInMethod(FormalParameter formalParameter, int blockOffset,
       int blockEnd) {
     Block block = AstFactory.block();
     block.leftBracket.offset = blockOffset;
     block.rightBracket.offset = blockEnd - 1;
     BlockFunctionBody body = AstFactory.blockFunctionBody(block);
     AstFactory.methodDeclaration2(
         null,
         null,
         null,
@@ skipping 604 matching lines @@
         new ErrorReporter(listener, firstType.element.source);
     reporter.reportTypeErrorForNode(
         StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE,
         AstFactory.identifier3("x"),
         [firstType, secondType]);
     AnalysisError error = listener.errors[0];
     expect(error.message.indexOf("(") >= 0, isTrue);
   }
 }
 
-
 @reflectiveTest
 class ErrorSeverityTest extends EngineTestCase {
   void test_max_error_error() {
     expect(
         ErrorSeverity.ERROR.max(ErrorSeverity.ERROR),
         same(ErrorSeverity.ERROR));
   }
 
   void test_max_error_none() {
     expect(
@@ skipping 538 matching lines @@
   void _assertHasReturn(bool expectedResult, String source) {
     Statement statement = ParserTestCase.parseStatement(source);
     expect(ExitDetector.exits(statement), expectedResult);
   }
 
   void _assertTrue(String source) {
     _assertHasReturn(true, source);
   }
 }
 
+
 /**
  * Tests for the [ExitDetector] that require that the AST be resolved.
  *
  * See [ExitDetectorTest] for tests that do not require the AST to be resolved.
  */
 @reflectiveTest
 class ExitDetectorTest2 extends ResolverTestCase {
   void test_switch_withEnum_false_noDefault() {
     Source source = addSource(r'''
 enum E { A, B }
@@ skipping 358 matching lines @@
   void test_resolve_nonFile() {
     UriResolver resolver = new FileUriResolver();
     Source result =
         resolver.resolveAbsolute(parseUriWithException("dart:core"));
     expect(result, isNull);
   }
 }
 
 
 @reflectiveTest
-class CustomUriResolverTest {
-  void test_creation() {
-    expect(new CustomUriResolver({}), isNotNull);
-  }
-
-  void test_resolve_unknown_uri() {
-    UriResolver resolver = new CustomUriResolver({
-      'custom:library': '/path/to/library.dart',
-    });
-    Source result = resolver.resolveAbsolute(
-        parseUriWithException("custom:non_library"));
-    expect(result, isNull);
-  }
-
-  void test_resolve_uri() {
-    String path =
-        FileUtilities2.createFile("/path/to/library.dart").getAbsolutePath();
-    UriResolver resolver = new CustomUriResolver({
-      'custom:library': path,
-    });
-    Source result = resolver.resolveAbsolute(
-        parseUriWithException("custom:library"));
-    expect(result, isNotNull);
-    expect(result.fullName, path);
-  }
-}
-
-
-@reflectiveTest
 class HtmlParserTest extends EngineTestCase {
   /**
    * The name of the 'script' tag in an HTML file.
    */
   static String _TAG_SCRIPT = "script";
   void fail_parse_scriptWithComment() {
     String scriptBody = r'''
       /**
        *     <editable-label bind-value="dartAsignableValue">
        *     </editable-label>
@@ skipping 1231 matching lines @@
     } else {
       expect(scriptSource, isNotNull, reason: "script $scriptIndex");
       String actualExternalScriptName = scriptSource.shortName;
       expect(
           actualExternalScriptName,
           _expectedExternalScriptName,
           reason: "script $scriptIndex");
     }
   }
 }