Introduce DartType super hierarchy based on Entity

pkg/compiler/lib/src/elements/types.dart

Index: pkg/compiler/lib/src/elements/types.dart
diff --git a/pkg/compiler/lib/src/elements/types.dart b/pkg/compiler/lib/src/elements/types.dart
new file mode 100644
index 0000000000000000000000000000000000000000..a84caa801eb761ab3904d23c992c6024d91d9402
--- /dev/null
+++ b/pkg/compiler/lib/src/elements/types.dart
@@ -0,0 +1,72 @@
+// Copyright (c) 2016, 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.
+
+import 'entities.dart';
+
+abstract class DartType {

[Siggi Cherem (dart-lang), 2016/12/22 15:42:03]

mmmm... I wonder if we should pick a different name here. We can always use
prefixes to disambiguate, but since we already have 2 type hierarchies
(dart_type and kernel) with similar classes (e.g. InterfaceType is defined in
both) I wonder if 3 would get a bit too confusing?

I don't yet have good suggestions for a different name, but some things that
might help:
  - add a dartdoc to this library and dart_type explaining the difference
between the two.
  - add some TODOs to clarify the direction these interfaces are headed into,
for example:
      - e.g. the compiler will depend on entities + type entities
      - dart_type will become just an implementation type

Other ideas:
  - maybe rename dart_type.dart to something else? elements/resolved_types.dart?
  - create lib/src/entitites/ with entities.dart and types.dart?
  - since the distinction between entity and element is very subtle, maybe
rename entity => element, and element => resolvedelement ? More precisely, 
      ClassEntity                   => ClassElement
      element_types.InterfaceType   => InterfaceType
      ClassElement                  => ResolvedClassElement (bc it results from
resolution)
      dart_types.InterfaceType      => ResolvedInterfaceType

  so in terms of libraries they would respectively be stored as:
      elements/elements.dart
      elements/types.dart
      elements/resolved_elements.dart or resolution/elements.dart
      elements/resolved_types.dart    or resolution/types.dart

  and 
     elements/modelx.dart  => elements/resolved_elements_impl.dart
                           or resolution/elements_impl.dart


Thoughts?

[Johnni Winther, 2016/12/22 15:58:49]

Good ideas. I'll pause this CL and make the renaming in a separate CL.

[Johnni Winther, 2017/01/04 09:52:39]

Dartdoc added.

+  /// Returns the unaliased type of this type.
+  ///
+  /// The unaliased type of a typedef'd type is the unaliased type to which its
+  /// name is bound. The unaliased version of any other type is the type itself.
+  ///
+  /// For example, the unaliased type of `typedef A Func<A,B>(B b)` is the
+  /// function type `(B) -> A` and the unaliased type of `Func<int,String>`
+  /// is the function type `(String) -> int`.
+  DartType get unaliased;
+
+  /// Is `true` if this type has no non-dynamic type arguments.
+  bool get treatAsRaw;
+
+  /// Is `true` if this type should be treated as the dynamic type.
+  bool get treatAsDynamic;
+
+  /// Is `true` if this type is the dynamic type.
+  bool get isDynamic;
+
+  /// Is `true` if this type is the void type.
+  bool get isVoid;
+
+  /// Is `true` if this is the type of `Object` from dart:core.
+  bool get isObject;
+
+  /// Is `true` if this type is an interface type.
+  bool get isInterfaceType;
+
+  /// Is `true` if this type is a typedef.
+  bool get isTypedef;
+
+  /// Is `true` if this type is a function type.
+  bool get isFunctionType;
+
+  /// Is `true` if this type is a type variable.
+  bool get isTypeVariable;
+
+  /// Is `true` if this type is a malformed type.
+  bool get isMalformed;
+}
+
+abstract class InterfaceType extends DartType {
+  ClassEntity get element;
+}
+
+abstract class TypeVariableType extends DartType {
+  TypeVariableEntity get element;
+}
+
+abstract class VoidType extends DartType {}
+
+abstract class DynamicType extends DartType {}
+
+abstract class FunctionType extends DartType {
+  DartType get returnType;
+  List<DartType> get parameterTypes;
+  List<DartType> get optionalParameterTypes;
+
+  /// The names of the named parameters ordered lexicographically.
+  List<String> get namedParameters;
+
+  /// The types of the named parameters in the order corresponding to the
+  /// [namedParameters].
+  List<DartType> get namedParameterTypes;
+}