Semantic highlighting for LABEL elements.

pkg/analysis_server/test/computer/element_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 test.computer.element;
 
 import 'package:analysis_server/src/protocol.dart';
-import '../abstract_context.dart';
-import '../reflective_tests.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart' as engine;
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart' as engine;
 import 'package:unittest/unittest.dart';
 
+import '../abstract_context.dart';
+import '../reflective_tests.dart';
+
 
 
 main() {
   groupSep = ' | ';
   runReflectiveTests(ElementTest);
   runReflectiveTests(ElementKindTest);
 }
 
 
 class ElementKindTest {
@@ skipping 13 matching lines @@
     expect(
         new ElementKind.fromEngine(engine.ElementKind.FUNCTION),
         ElementKind.FUNCTION);
     expect(
         new ElementKind.fromEngine(engine.ElementKind.FUNCTION_TYPE_ALIAS),
         ElementKind.FUNCTION_TYPE_ALIAS);
     expect(
         new ElementKind.fromEngine(engine.ElementKind.GETTER),
         ElementKind.GETTER);
     expect(
+        new ElementKind.fromEngine(engine.ElementKind.LABEL),
+        ElementKind.LABEL);
+    expect(
         new ElementKind.fromEngine(engine.ElementKind.LIBRARY),
         ElementKind.LIBRARY);
     expect(
         new ElementKind.fromEngine(engine.ElementKind.LOCAL_VARIABLE),
         ElementKind.LOCAL_VARIABLE);
     expect(
         new ElementKind.fromEngine(engine.ElementKind.METHOD),
         ElementKind.METHOD);
     expect(
         new ElementKind.fromEngine(engine.ElementKind.PARAMETER),
@@ skipping 17 matching lines @@
     expect(
         new ElementKind(ElementKind.CLASS_TYPE_ALIAS.name),
         ElementKind.CLASS_TYPE_ALIAS);
     expect(
         new ElementKind(ElementKind.COMPILATION_UNIT.name),
         ElementKind.COMPILATION_UNIT);
     expect(
         new ElementKind(ElementKind.CONSTRUCTOR.name),
         ElementKind.CONSTRUCTOR);
     expect(new ElementKind(ElementKind.FIELD.name), ElementKind.FIELD);
-    expect(
-        new ElementKind(ElementKind.FUNCTION.name),
-        ElementKind.FUNCTION);
+    expect(new ElementKind(ElementKind.FUNCTION.name), ElementKind.FUNCTION);
     expect(
         new ElementKind(ElementKind.FUNCTION_TYPE_ALIAS.name),
         ElementKind.FUNCTION_TYPE_ALIAS);
     expect(new ElementKind(ElementKind.GETTER.name), ElementKind.GETTER);
     expect(new ElementKind(ElementKind.LIBRARY.name), ElementKind.LIBRARY);
     expect(
         new ElementKind(ElementKind.LOCAL_VARIABLE.name),
         ElementKind.LOCAL_VARIABLE);
     expect(new ElementKind(ElementKind.METHOD.name), ElementKind.METHOD);
-    expect(
-        new ElementKind(ElementKind.PARAMETER.name),
-        ElementKind.PARAMETER);
+    expect(new ElementKind(ElementKind.PARAMETER.name), ElementKind.PARAMETER);
     expect(new ElementKind(ElementKind.SETTER.name), ElementKind.SETTER);
     expect(
         new ElementKind(ElementKind.TOP_LEVEL_VARIABLE.name),
         ElementKind.TOP_LEVEL_VARIABLE);
     expect(
         new ElementKind(ElementKind.TYPE_PARAMETER.name),
         ElementKind.TYPE_PARAMETER);
     expect(
         new ElementKind(ElementKind.UNIT_TEST_TEST.name),
         ElementKind.UNIT_TEST_TEST);
     expect(
         new ElementKind(ElementKind.UNIT_TEST_GROUP.name),
         ElementKind.UNIT_TEST_GROUP);
     expect(new ElementKind(ElementKind.UNKNOWN.name), ElementKind.UNKNOWN);
     expect(() {
       new ElementKind('no-such-kind');
     }, throws);
   }
 
   void test_toString() {
     expect(ElementKind.CLASS.toString(), 'ElementKind.CLASS');
-    expect(ElementKind.COMPILATION_UNIT.toString(),
+    expect(
+        ElementKind.COMPILATION_UNIT.toString(),
         'ElementKind.COMPILATION_UNIT');
   }
 }
 
 
 @ReflectiveTestCase()
 class ElementTest extends AbstractContextTest {
   engine.Element findElementInUnit(CompilationUnit unit, String name,
       [engine.ElementKind kind]) {
     return findChildElement(unit.element, name, kind);
@@ skipping 89 matching lines @@
       expect(location.offset, 19);
       expect(location.length, 'myGetter'.length);
       expect(location.startLine, 2);
       expect(location.startColumn, 10);
     }
     expect(element.parameters, '()');
     expect(element.returnType, 'String');
     expect(element.flags, 0);
   }
 
+  void test_fromElement_LABEL() {
+    Source source = addSource('/test.dart', '''
+main() {
+myLabel:
+  while (true) {
+    break myLabel;
+  }
+}''');
+    CompilationUnit unit = resolveLibraryUnit(source);
+    engine.LabelElement engineElement = findElementInUnit(unit, 'myLabel');
+    // create notification Element
+    Element element = new Element.fromEngine(engineElement);
+    expect(element.kind, ElementKind.LABEL);
+    expect(element.name, 'myLabel');
+    {
+      Location location = element.location;
+      expect(location.file, '/test.dart');
+      expect(location.offset, 9);
+      expect(location.length, 'myLabel'.length);
+      expect(location.startLine, 2);
+      expect(location.startColumn, 1);
+    }
+    expect(element.parameters, isNull);
+    expect(element.returnType, isNull);
+    expect(element.flags, 0);
+  }
+
   void test_fromElement_METHOD() {
     Source source = addSource('/test.dart', '''
 class A {
   static List<String> myMethod(int a, {String b}) {
     return null;
   }
 }''');
     CompilationUnit unit = resolveLibraryUnit(source);
     engine.MethodElement engineElement = findElementInUnit(unit, 'myMethod');
     // create notification Element
@@ skipping 18 matching lines @@
     // create notification Element
     Element element = new Element.fromEngine(engineElement);
     expect(element.kind, ElementKind.UNKNOWN);
     expect(element.name, 'dynamic');
     expect(element.location, isNull);
     expect(element.parameters, isNull);
     expect(element.returnType, isNull);
     expect(element.flags, 0);
   }
 }