Use elements/types.dart in codegen.dart

pkg/compiler/lib/src/ssa/nodes.dart

 // Copyright (c) 2012, 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 '../closure.dart';
 import '../common.dart';
 import '../common/backend_api.dart' show BackendClasses;
 import '../compiler.dart' show Compiler;
 import '../constants/constant_system.dart';
 import '../constants/values.dart';
@@ skipping 3275 matching lines @@
 /// The COMPLETE form value is constructed from [dartType] by replacing the type
 /// variables with consecutive values from [inputs], in the order generated by
 /// [DartType.forEachTypeVariable].  The type variables in [dartType] are
 /// treated as 'holes' in the term, which means that it must be ensured at
 /// construction, that duplicate occurences of a type variable in [dartType] are
 /// assigned the same value.
 ///
 /// The INSTANCE form is constructed as a list of [inputs]. This is the same as
 /// the COMPLETE form for the 'thisType', except the root term's type is
 /// missing; this is implicit as the raw type of instance.  The [dartType] of
-/// the INSTANCE form must be the thisType of some class.
+/// the INSTANCE form must be a raw type of some class.

[sra1, 2017/01/04 17:16:03]

Can we avoid this change?
It breaks the invariant that each type variable in the dartType corresponds to
an input.

INSTANCE/COMPLETE is an unfortunate distinction because the *current* reified
representation is 'headless', with the outermost term being implicit.  This will
change if/when we store a complete reified type (e.g see TODO below).

Type-forwarding optimizations rely on being able to call asInstanceOf, which
gives different results for raw- and this- types.

[Johnni Winther, 2017/01/06 10:24:04]

Done.

 ///
 /// We want to remove the constrains on the INSTANCE form. In the meantime we
 /// get by with a tree of TypeExpressions.  Consider:
 ///
 ///     class Foo<T> {
 ///       ... new Set<List<T>>()
 ///     }
 ///     class Set<E1> {
 ///       factory Set() => new _LinkedHashSet<E1>();
 ///     }
@@ skipping 13 matching lines @@
 
 // TODO(sra): The INSTANCE form requires the actual instance for full
 // interpretation. If the COMPLETE form was used on instances, then we could
 // simplify HTypeInfoReadVariable without an object.
 
 class HTypeInfoExpression extends HInstruction {
   final TypeInfoExpressionKind kind;
   final DartType dartType;
   HTypeInfoExpression(this.kind, this.dartType, List<HInstruction> inputs,
       TypeMask instructionType)
       : super(inputs, instructionType) {

[sra1, 2017/01/04 17:16:03]

We could assert here that the number of type variables in dartType corresponds
to the number of inputs.

[Johnni Winther, 2017/01/06 10:24:04]

Done.

     setUseGvn();
   }
 
   accept(HVisitor visitor) => visitor.visitTypeInfoExpression(this);
 
   bool canThrow() => false;
 
   int typeCode() => HInstruction.TYPE_INFO_EXPRESSION_TYPECODE;
   bool typeEquals(HInstruction other) => other is HTypeInfoExpression;
 
@@ skipping 107 matching lines @@
 class HDynamicType extends HRuntimeType {
   HDynamicType(DynamicType dartType, TypeMask instructionType)
       : super(const <HInstruction>[], dartType, instructionType);
 
   accept(HVisitor visitor) => visitor.visitDynamicType(this);
 
   int typeCode() => HInstruction.DYNAMIC_TYPE_TYPECODE;
 
   bool typeEquals(HInstruction other) => other is HDynamicType;
 }