Support typedef type literals

pkg/compiler/lib/src/kernel/element_map_impl.dart

 // Copyright (c) 2017, 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 dart2js.kernel.element_map;
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../closure.dart' show BoxLocal;
 import '../common.dart';
@@ skipping 64 matching lines @@
   KernelConstantEnvironment _constantEnvironment;
   _KernelDartTypes _types;
 
   /// Library environment. Used for fast lookup.
   ProgramEnv _env = new ProgramEnv();
 
   List<LibraryEntity> _libraryList = <LibraryEntity>[];
   List<ClassEntity> _classList = <ClassEntity>[];
   List<MemberEntity> _memberList = <MemberEntity>[];
   List<TypeVariableEntity> _typeVariableList = <TypeVariableEntity>[];
+  List<TypedefEntity> _typedefList = <TypedefEntity>[];
 
   /// List of library environments by `IndexedLibrary.libraryIndex`. This is
   /// used for fast lookup into library classes and members.
   List<LibraryEnv> _libraryEnvs = <LibraryEnv>[];
 
   /// List of library data by `IndexedLibrary.libraryIndex`. This is used for
   /// fast lookup into library properties.
   List<LibraryData> _libraryData = <LibraryData>[];
 
   /// List of class environments by `IndexedClass.classIndex`. This is used for
   /// fast lookup into class members.
   List<ClassEnv> _classEnvs = <ClassEnv>[];
 
   /// List of class data by `IndexedClass.classIndex`. This is used for
   /// fast lookup into class properties.
   List<ClassData> _classData = <ClassData>[];
 
   /// List of member data by `IndexedMember.memberIndex`. This is used for
   /// fast lookup into member properties.
   List<MemberData> _memberData = <MemberData>[];
 
+  /// List of typedef data by `IndexedTypedef.typedefIndex`. This is used for
+  /// fast lookup into typedef properties.
+  List<TypedefData> _typedefData = <TypedefData>[];
+
   KernelToElementMapBase(this.reporter, Environment environment) {
     _elementEnvironment = new KernelElementEnvironment(this);
     _commonElements = new CommonElements(_elementEnvironment);
     _constantEnvironment = new KernelConstantEnvironment(this, environment);
     _typeConverter = new DartTypeConverter(this);
     _types = new _KernelDartTypes(this);
   }
 
   bool checkFamily(Entity entity);
 
@@ skipping 201 matching lines @@
         OrderedTypeSetBuilder setBuilder =
             new _KernelOrderedTypeSetBuilder(this, cls);
         data.orderedTypeSet = setBuilder.createOrderedTypeSet(
             data.supertype, interfaces.reverse());
         data.interfaces = new List<InterfaceType>.from(interfaces.toList());
       }
     }
   }
 
   @override
+  TypedefType getTypedefType(ir.Typedef node) {
+    IndexedTypedef typedef = _getTypedef(node);
+    return _typedefData[typedef.typedefIndex].rawType;
+  }
+
+  TypedefEntity _getTypedef(ir.Typedef node);
+
+  @override
   MemberEntity getMember(ir.Member node) {
     if (node is ir.Field) {
       return _getField(node);
     } else if (node is ir.Constructor) {
       return _getConstructor(node);
     } else if (node is ir.Procedure) {
       if (node.kind == ir.ProcedureKind.Factory) {
         return _getConstructor(node);
       } else {
         return _getMethod(node);
@@ skipping 267 matching lines @@
   ProgramEnv get _env;
   List<LibraryEntity> get _libraryList;
   List<LibraryEnv> get _libraryEnvs;
   List<LibraryData> get _libraryData;
   List<ClassEntity> get _classList;
   List<ClassEnv> get _classEnvs;
   List<ClassData> get _classData;
   List<MemberEntity> get _memberList;
   List<MemberData> get _memberData;
   List<TypeVariableEntity> get _typeVariableList;
+  List<TypedefEntity> get _typedefList;
+  List<TypedefData> get _typedefData;

[Siggi Cherem (dart-lang), 2017/08/09 16:38:07]

given we have so many of these now, it might be worth adding a datatype that
helps keep the invariants straight. For example, something with this flavor:

class FastLookupMap<K extends IndexableItem, V> {
  List<K> keys;
  List<V> values;

  void operator []=(K key, V value) {
    var index = keys.length;
    assert (key.index == null);
    key.index = key;
    keys.add(key);
    values.add(value);
  }

  // or if we want to make the index final, then:
  void put(K createKey(int index), V createValue(K key)) {
    var index = keys.length;
    key = createKey(index);
    keys.add(key);
    values.add(createValue(key));
  }

  void operator [](K key) => values[key.index];
}

that would deal with the fact that list/data are the same length and are
consistently updated?

[Johnni Winther, 2017/08/10 08:18:34]

Acknowledged. Will do in a follow-up.

 
   Map<ir.Library, IndexedLibrary> _libraryMap = <ir.Library, IndexedLibrary>{};
   Map<ir.Class, IndexedClass> _classMap = <ir.Class, IndexedClass>{};
+  Map<ir.Typedef, IndexedTypedef> _typedefMap = <ir.Typedef, IndexedTypedef>{};
   Map<ir.TypeParameter, IndexedTypeVariable> _typeVariableMap =
       <ir.TypeParameter, IndexedTypeVariable>{};
   Map<ir.Member, IndexedConstructor> _constructorMap =
       <ir.Member, IndexedConstructor>{};
   Map<ir.Procedure, IndexedFunction> _methodMap =
       <ir.Procedure, IndexedFunction>{};
   Map<ir.Field, IndexedField> _fieldMap = <ir.Field, IndexedField>{};
   Map<ir.TreeNode, Local> _localFunctionMap = <ir.TreeNode, Local>{};
 
   Name getName(ir.Name node);
@@ skipping 37 matching lines @@
       _classEnvs.add(classEnv);
       ClassEntity cls = createClass(library, _classList.length, node.name,
           isAbstract: node.isAbstract);
       _classData
           .add(new ClassData(node, new RegularClassDefinition(cls, node)));
       _classList.add(cls);
       return cls;
     });
   }
 
+  TypedefEntity _getTypedef(ir.Typedef node) {
+    return _typedefMap.putIfAbsent(node, () {
+      IndexedLibrary library = _getLibrary(node.enclosingLibrary);
+      TypedefEntity typedef =
+          createTypedef(library, _typedefList.length, node.name);
+      TypedefType typedefType = new TypedefType(
+          typedef,
+          new List<DartType>.filled(
+              node.typeParameters.length, const DynamicType()));
+      _typedefData.add(new TypedefData(node, typedef, typedefType));
+      _typedefList.add(typedef);
+      return typedef;
+    });
+  }
+
   TypeVariableEntity _getTypeVariable(ir.TypeParameter node) {
     return _typeVariableMap.putIfAbsent(node, () {
       if (node.parent is ir.Class) {
         int typeVariableIndex = _typeVariableList.length;
         ir.Class cls = node.parent;
         int index = cls.typeParameters.indexOf(node);
         TypeVariableEntity typeVariable = createTypeVariable(
             typeVariableIndex, _getClass(cls), node.name, index);
         _typeVariableList.add(typeVariable);
         return typeVariable;
@@ skipping 164 matching lines @@
         node.namedParameters.map((p) => p.name).toList()..sort();
     return new ParameterStructure(
         requiredParameters, positionalParameters, namedParameters);
   }
 
   IndexedLibrary createLibrary(int libraryIndex, String name, Uri canonicalUri);
 
   IndexedClass createClass(LibraryEntity library, int classIndex, String name,
       {bool isAbstract});
 
+  IndexedTypedef createTypedef(
+      LibraryEntity library, int typedefIndex, String name);
+
   TypeVariableEntity createTypeVariable(
       int typeVariableIndex, Entity typeDeclaration, String name, int index);
 
   IndexedConstructor createGenerativeConstructor(
       int memberIndex,
       ClassEntity enclosingClass,
       Name name,
       ParameterStructure parameterStructure,
       {bool isExternal,
       bool isConst});
@@ skipping 36 matching lines @@
   IndexedLibrary createLibrary(
       int libraryIndex, String name, Uri canonicalUri) {
     return new KLibrary(libraryIndex, name, canonicalUri);
   }
 
   IndexedClass createClass(LibraryEntity library, int classIndex, String name,
       {bool isAbstract}) {
     return new KClass(library, classIndex, name, isAbstract: isAbstract);
   }
 
+  @override
+  IndexedTypedef createTypedef(
+      LibraryEntity library, int typedefIndex, String name) {
+    throw new UnsupportedError('KElementCreatorMixin.createTypedef');
+  }
+
   TypeVariableEntity createTypeVariable(
       int typeVariableIndex, Entity typeDeclaration, String name, int index) {
     return new KTypeVariable(typeVariableIndex, typeDeclaration, name, index);
   }
 
   IndexedConstructor createGenerativeConstructor(
       int memberIndex,
       ClassEntity enclosingClass,
       Name name,
       ParameterStructure parameterStructure,
@@ skipping 1193 matching lines @@
   ///
   /// These names are not used in generated code, just as element name.
   String _getClosureVariableName(String name, int id) {
     return "_captured_${name}_$id";
   }
 
   String getDeferredUri(ir.LibraryDependency node) {
     throw new UnimplementedError('JsKernelToElementMap.getDeferredUri');
   }
 }