Remove the Polymer support from the analyzer and analysis_server packages.

pkg/analyzer/test/generated/engine_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.engine_test;
 
 import 'dart:async';
@@ skipping 2230 matching lines @@
 }
 
 
 @ReflectiveTestCase()
 class AnalysisOptionsImplTest extends EngineTestCase {
   void test_AnalysisOptionsImpl_copy() {
     bool booleanValue = true;
     for (int i = 0; i < 2; i++, booleanValue = !booleanValue) {
       AnalysisOptionsImpl options = new AnalysisOptionsImpl();
       options.analyzeFunctionBodies = booleanValue;
-      options.analyzePolymer = booleanValue;
       options.cacheSize = i;
       options.dart2jsHint = booleanValue;
       options.enableDeferredLoading = booleanValue;
       options.generateSdkErrors = booleanValue;
       options.hint = booleanValue;
       options.incremental = booleanValue;
       options.preserveComments = booleanValue;
       AnalysisOptionsImpl copy = new AnalysisOptionsImpl.con1(options);
       expect(copy.analyzeFunctionBodies, options.analyzeFunctionBodies);
-      expect(copy.analyzePolymer, options.analyzePolymer);
       expect(copy.cacheSize, options.cacheSize);
       expect(copy.dart2jsHint, options.dart2jsHint);
       expect(copy.enableDeferredLoading, options.enableDeferredLoading);
       expect(copy.enableEnum, options.enableEnum);
       expect(copy.generateSdkErrors, options.generateSdkErrors);
       expect(copy.hint, options.hint);
       expect(copy.incremental, options.incremental);
       expect(copy.preserveComments, options.preserveComments);
     }
   }
 
   void test_getAnalyzeFunctionBodies() {
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
     bool value = !options.analyzeFunctionBodies;
     options.analyzeFunctionBodies = value;
     expect(options.analyzeFunctionBodies, value);
   }
 
-  void test_getAnalyzePolymer() {
-    AnalysisOptionsImpl options = new AnalysisOptionsImpl();
-    bool value = !options.analyzePolymer;
-    options.analyzePolymer = value;
-    expect(options.analyzePolymer, value);
-  }
-
   void test_getCacheSize() {
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
     expect(options.cacheSize, AnalysisOptionsImpl.DEFAULT_CACHE_SIZE);
     int value = options.cacheSize + 1;
     options.cacheSize = value;
     expect(options.cacheSize, value);
   }
 
   void test_getDart2jsHint() {
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
@@ skipping 1836 matching lines @@
     expect(entry.allErrors, hasLength(0));
     entry.setValue(
         HtmlEntry.PARSE_ERRORS,
         <AnalysisError>[
             new AnalysisError.con1(source, ParserErrorCode.EXPECTED_TOKEN, [";"])]);
     entry.setValue(
         HtmlEntry.RESOLUTION_ERRORS,
         <AnalysisError>[
             new AnalysisError.con1(source, HtmlWarningCode.INVALID_URI, ["-"])]);
     entry.setValue(
-        HtmlEntry.POLYMER_BUILD_ERRORS,
-        <AnalysisError>[
-            new AnalysisError.con1(source, PolymerCode.INVALID_ATTRIBUTE_NAME, ["-"])]);
-    entry.setValue(
-        HtmlEntry.POLYMER_RESOLUTION_ERRORS,
-        <AnalysisError>[
-            new AnalysisError.con1(source, PolymerCode.INVALID_ATTRIBUTE_NAME, ["-"])]);
-    entry.setValue(
         HtmlEntry.HINTS,
         <AnalysisError>[new AnalysisError.con1(source, HintCode.DEAD_CODE)]);
-    expect(entry.allErrors, hasLength(5));
+    expect(entry.allErrors, hasLength(3));
   }
 
   void test_invalidateAllResolutionInformation() {
     HtmlEntry entry = _entryWithValidState();
     entry.invalidateAllResolutionInformation(false);
-    expect(
-        entry.getState(HtmlEntry.POLYMER_BUILD_ERRORS),
-        same(CacheState.INVALID));
-    expect(
-        entry.getState(HtmlEntry.POLYMER_RESOLUTION_ERRORS),
-        same(CacheState.INVALID));
     expect(entry.getState(HtmlEntry.ELEMENT), same(CacheState.INVALID));
     expect(entry.getState(HtmlEntry.HINTS), same(CacheState.INVALID));
     expect(entry.getState(SourceEntry.LINE_INFO), same(CacheState.VALID));
     expect(entry.getState(HtmlEntry.PARSE_ERRORS), same(CacheState.VALID));
     expect(entry.getState(HtmlEntry.PARSED_UNIT), same(CacheState.VALID));
     expect(
         entry.getState(HtmlEntry.REFERENCED_LIBRARIES),
         same(CacheState.VALID));
     expect(
         entry.getState(HtmlEntry.RESOLUTION_ERRORS),
         same(CacheState.INVALID));
   }
 
   void test_invalidateAllResolutionInformation_includingUris() {
     HtmlEntry entry = _entryWithValidState();
     entry.invalidateAllResolutionInformation(true);
-    expect(
-        entry.getState(HtmlEntry.POLYMER_BUILD_ERRORS),
-        same(CacheState.INVALID));
-    expect(
-        entry.getState(HtmlEntry.POLYMER_RESOLUTION_ERRORS),
-        same(CacheState.INVALID));
     expect(entry.getState(HtmlEntry.ELEMENT), same(CacheState.INVALID));
     expect(entry.getState(HtmlEntry.HINTS), same(CacheState.INVALID));
     expect(entry.getState(SourceEntry.LINE_INFO), same(CacheState.VALID));
     expect(entry.getState(HtmlEntry.PARSE_ERRORS), same(CacheState.VALID));
     expect(entry.getState(HtmlEntry.PARSED_UNIT), same(CacheState.VALID));
     expect(
         entry.getState(HtmlEntry.REFERENCED_LIBRARIES),
         same(CacheState.INVALID));
     expect(
         entry.getState(HtmlEntry.RESOLUTION_ERRORS),
@@ skipping 13 matching lines @@
   }
 
   void test_setState_parsedUnit() {
     state = HtmlEntry.PARSED_UNIT;
   }
 
   void test_setState_parseErrors() {
     state = HtmlEntry.PARSE_ERRORS;
   }
 
-  void test_setState_polymerBuildErrors() {
-    state = HtmlEntry.POLYMER_BUILD_ERRORS;
-  }
-
-  void test_setState_polymerResolutionErrors() {
-    state = HtmlEntry.POLYMER_RESOLUTION_ERRORS;
-  }
-
   void test_setState_referencedLibraries() {
     state = HtmlEntry.REFERENCED_LIBRARIES;
   }
 
   void test_setState_resolutionErrors() {
     state = HtmlEntry.RESOLUTION_ERRORS;
   }
 
   void test_setValue_element() {
     _setValue(HtmlEntry.ELEMENT, new HtmlElementImpl(null, "test.html"));
@@ skipping 22 matching lines @@
     _setValue(HtmlEntry.PARSED_UNIT, new ht.HtmlUnit(null, null, null));
   }
 
   void test_setValue_parseErrors() {
     _setValue(
         HtmlEntry.PARSE_ERRORS,
         <AnalysisError>[
             new AnalysisError.con1(null, HtmlWarningCode.INVALID_URI, ["-"])]);
   }
 
-  void test_setValue_polymerBuildErrors() {
-    _setValue(
-        HtmlEntry.POLYMER_BUILD_ERRORS,
-        <AnalysisError>[
-            new AnalysisError.con1(null, PolymerCode.INVALID_ATTRIBUTE_NAME, ["-"])]);
-  }
-
-  void test_setValue_polymerResolutionErrors() {
-    _setValue(
-        HtmlEntry.POLYMER_RESOLUTION_ERRORS,
-        <AnalysisError>[
-            new AnalysisError.con1(null, PolymerCode.INVALID_ATTRIBUTE_NAME, ["-"])]);
-  }
-
   void test_setValue_referencedLibraries() {
     _setValue(HtmlEntry.REFERENCED_LIBRARIES, <Source>[new TestSource()]);
   }
 
   void test_setValue_resolutionErrors() {
     _setValue(
         HtmlEntry.RESOLUTION_ERRORS,
         <AnalysisError>[
             new AnalysisError.con1(null, HtmlWarningCode.INVALID_URI, ["-"])]);
   }
 
   HtmlEntry _entryWithValidState() {
     HtmlEntry entry = new HtmlEntry();
     entry.setValue(HtmlEntry.ELEMENT, null);
     entry.setValue(HtmlEntry.HINTS, null);
     entry.setValue(SourceEntry.LINE_INFO, null);
     entry.setValue(HtmlEntry.PARSE_ERRORS, null);
     entry.setValue(HtmlEntry.PARSED_UNIT, null);
-    entry.setValue(HtmlEntry.POLYMER_BUILD_ERRORS, null);
-    entry.setValue(HtmlEntry.POLYMER_RESOLUTION_ERRORS, null);
     entry.setValue(HtmlEntry.REFERENCED_LIBRARIES, null);
     entry.setValue(HtmlEntry.RESOLUTION_ERRORS, null);
     expect(entry.getState(HtmlEntry.ELEMENT), same(CacheState.VALID));
     expect(entry.getState(HtmlEntry.HINTS), same(CacheState.VALID));
     expect(entry.getState(SourceEntry.LINE_INFO), same(CacheState.VALID));
     expect(entry.getState(HtmlEntry.PARSE_ERRORS), same(CacheState.VALID));
     expect(entry.getState(HtmlEntry.PARSED_UNIT), same(CacheState.VALID));
     expect(
-        entry.getState(HtmlEntry.POLYMER_BUILD_ERRORS),
-        same(CacheState.VALID));
-    expect(
-        entry.getState(HtmlEntry.POLYMER_RESOLUTION_ERRORS),
-        same(CacheState.VALID));
-    expect(
         entry.getState(HtmlEntry.REFERENCED_LIBRARIES),
         same(CacheState.VALID));
     expect(entry.getState(HtmlEntry.RESOLUTION_ERRORS), same(CacheState.VALID));
     return entry;
   }
 
   void _setValue(DataDescriptor descriptor, Object newValue) {
     HtmlEntry entry = new HtmlEntry();
     Object value = entry.getValue(descriptor);
     expect(newValue, isNot(same(value)));
@@ skipping 2459 matching lines @@
   E visitParseDartTask(ParseDartTask task) {
     fail("Unexpectedly invoked visitParseDartTask");
     return null;
   }
   @override
   E visitParseHtmlTask(ParseHtmlTask task) {
     fail("Unexpectedly invoked visitParseHtmlTask");
     return null;
   }
   @override
-  E visitPolymerBuildHtmlTask(PolymerBuildHtmlTask task) {
-    fail("Unexpectedly invoked visitPolymerBuildHtmlTask");
-    return null;
-  }
-  @override
-  E visitPolymerResolveHtmlTask(PolymerResolveHtmlTask task) {
-    fail("Unexpectedly invoked visitPolymerResolveHtmlTask");
-    return null;
-  }
-  @override
   E visitResolveDartLibraryCycleTask(ResolveDartLibraryCycleTask task) {
     fail("Unexpectedly invoked visitResolveDartLibraryCycleTask");
     return null;
   }
   @override
   E visitResolveDartLibraryTask(ResolveDartLibraryTask task) {
     fail("Unexpectedly invoked visitResolveDartLibraryTask");
     return null;
   }
   @override
@@ skipping 193 matching lines @@
   bool contains(Source source) => source == libB;
 }
 
 
 class _UniversalCachePartitionTest_test_setMaxCacheSize implements
     CacheRetentionPolicy {
   @override
   RetentionPriority getAstPriority(Source source, SourceEntry sourceEntry) =>
       RetentionPriority.LOW;
 }