Start separating ClassElementImpl for Class and Enum.

pkg/analyzer/test/src/dart/element/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 analyzer.test.src.dart.element.element_test;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/constant/value.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
@@ skipping 2034 matching lines @@
     String namedParameterName = "c";
     functionElement.parameters = <ParameterElement>[
       ElementFactory.requiredParameter2("a", parameterType),
       ElementFactory.positionalParameter2("b", parameterType),
       ElementFactory.namedParameter2(namedParameterName, parameterType)
     ];
     functionElement.returnType = parameterType;
     definingClass.methods = <MethodElement>[functionElement];
     FunctionTypeImpl functionType = new FunctionTypeImpl(functionElement);
     InterfaceTypeImpl argumentType = new InterfaceTypeImpl(
-        new ClassElementImpl.forNode(AstFactory.identifier3("D")));
+        new ClassElementImpl_Class.forNode(AstFactory.identifier3("D")));
     FunctionType result = functionType
         .substitute2(<DartType>[argumentType], <DartType>[parameterType]);
     expect(result.returnType, argumentType);
     List<DartType> normalParameters = result.normalParameterTypes;
     expect(normalParameters, hasLength(1));
     expect(normalParameters[0], argumentType);
     List<DartType> optionalParameters = result.optionalParameterTypes;
     expect(optionalParameters, hasLength(1));
     expect(optionalParameters[0], argumentType);
     Map<String, DartType> namedParameters = result.namedParameterTypes;
     expect(namedParameters, hasLength(1));
     expect(namedParameters[namedParameterName], argumentType);
   }
 
   void test_substitute2_notEqual() {
     DartType returnType = new InterfaceTypeImpl(
-        new ClassElementImpl.forNode(AstFactory.identifier3("R")));
+        new ClassElementImpl_Class.forNode(AstFactory.identifier3("R")));
     DartType normalParameterType = new InterfaceTypeImpl(
-        new ClassElementImpl.forNode(AstFactory.identifier3("A")));
+        new ClassElementImpl_Class.forNode(AstFactory.identifier3("A")));
     DartType optionalParameterType = new InterfaceTypeImpl(
-        new ClassElementImpl.forNode(AstFactory.identifier3("B")));
+        new ClassElementImpl_Class.forNode(AstFactory.identifier3("B")));
     DartType namedParameterType = new InterfaceTypeImpl(
-        new ClassElementImpl.forNode(AstFactory.identifier3("C")));
+        new ClassElementImpl_Class.forNode(AstFactory.identifier3("C")));
     FunctionElementImpl functionElement =
         new FunctionElementImpl.forNode(AstFactory.identifier3("f"));
     String namedParameterName = "c";
     functionElement.parameters = <ParameterElement>[
       ElementFactory.requiredParameter2("a", normalParameterType),
       ElementFactory.positionalParameter2("b", optionalParameterType),
       ElementFactory.namedParameter2(namedParameterName, namedParameterType)
     ];
     functionElement.returnType = returnType;
     FunctionTypeImpl functionType = new FunctionTypeImpl(functionElement);
     InterfaceTypeImpl argumentType = new InterfaceTypeImpl(
-        new ClassElementImpl.forNode(AstFactory.identifier3("D")));
+        new ClassElementImpl_Class.forNode(AstFactory.identifier3("D")));
     TypeParameterTypeImpl parameterType = new TypeParameterTypeImpl(
         new TypeParameterElementImpl.forNode(AstFactory.identifier3("E")));
     FunctionType result = functionType
         .substitute2(<DartType>[argumentType], <DartType>[parameterType]);
     expect(result.returnType, returnType);
     List<DartType> normalParameters = result.normalParameterTypes;
     expect(normalParameters, hasLength(1));
     expect(normalParameters[0], normalParameterType);
     List<DartType> optionalParameters = result.optionalParameterTypes;
     expect(optionalParameters, hasLength(1));
@@ skipping 2258 matching lines @@
     // Returns whatever type is passed to resolveToBound().
     expect(type.resolveToBound(VoidTypeImpl.instance),
         same(VoidTypeImpl.instance));
   }
 
   void test_substitute_equal() {
     TypeParameterElementImpl element =
         new TypeParameterElementImpl.forNode(AstFactory.identifier3("E"));
     TypeParameterTypeImpl type = new TypeParameterTypeImpl(element);
     InterfaceTypeImpl argument = new InterfaceTypeImpl(
-        new ClassElementImpl.forNode(AstFactory.identifier3("A")));
+        new ClassElementImpl_Class.forNode(AstFactory.identifier3("A")));
     TypeParameterTypeImpl parameter = new TypeParameterTypeImpl(element);
     expect(type.substitute2(<DartType>[argument], <DartType>[parameter]),
         same(argument));
   }
 
   void test_substitute_notEqual() {
     TypeParameterTypeImpl type = new TypeParameterTypeImpl(
         new TypeParameterElementImpl.forNode(AstFactory.identifier3("E")));
     InterfaceTypeImpl argument = new InterfaceTypeImpl(
-        new ClassElementImpl.forNode(AstFactory.identifier3("A")));
+        new ClassElementImpl_Class.forNode(AstFactory.identifier3("A")));
     TypeParameterTypeImpl parameter = new TypeParameterTypeImpl(
         new TypeParameterElementImpl.forNode(AstFactory.identifier3("F")));
     expect(type.substitute2(<DartType>[argument], <DartType>[parameter]),
         same(type));
   }
 }
 
 @reflectiveTest
 class VoidTypeImplTest extends EngineTestCase {
   /**
@@ skipping 38 matching lines @@
 }
 
 class _FunctionTypeImplTest_isSubtypeOf_baseCase_classFunction
     extends InterfaceTypeImpl {
   _FunctionTypeImplTest_isSubtypeOf_baseCase_classFunction(ClassElement arg0)
       : super(arg0);
 
   @override
   bool get isDartCoreFunction => true;
 }