Support for constructor references in constant serializer and prelinker.

pkg/analyzer/lib/src/summary/prelink.dart

 // 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 'package:analyzer/src/summary/format.dart';
 import 'package:analyzer/src/summary/name_filter.dart';
 
 /**
  * Create a [LinkedLibraryBuilder] corresponding to the given
  * [definingUnit], which should be the defining compilation unit for a library.
@@ skipping 14 matching lines @@
  * the transitive closure of parts and exports reachable from those libraries).
  * [relativeUri] should be interpreted relative to the defining compilation
  * unit of the library being prelinked.
  *
  * If no file exists at the given uri, `null` should be returned.
  */
 typedef UnlinkedPublicNamespace GetImportCallback(String relativeUri);
 
 /**
  * Type of the callback used by the prelinker to obtain unlinked summaries of
- * part files of the library to be prelinked.  [relaviteUri] should be
+ * part files of the library to be prelinked.  [relativeUri] should be
  * interpreted relative to the defining compilation unit of the library being
  * prelinked.
  *
  * If no file exists at the given uri, `null` should be returned.
  */
 typedef UnlinkedUnit GetPartCallback(String relativeUri);
 
 /**
+ * A [_Meaning] representing a class.
+ */
+class _ClassMeaning extends _Meaning {
+  final Map<String, _Meaning> namespace;

[Paul Berry, 2016/01/26 00:47:21]

Instead of adding _ClassMeaning as a new class, I wonder if it would be better
to rename _PrefixMeaning to something more general (_MeaningWithNamespace
maybe?) and use it for both cases.

That would let us simplify the code down at line 408.

Your call, though.

[scheglov, 2016/01/26 04:34:49]

It could work, but in _PrefixMeaning all its _Meaning properties are static, and
for _ClassMeaning they are almost all different. We could add a common
superclass or a two constructors in one class. I don't know... I'm leaving it as
it for now.

+
+  _ClassMeaning(int unit, int dependency, int numTypeParameters, this.namespace)
+      : super(unit, ReferenceKind.classOrEnum, dependency, numTypeParameters);
+}
+
+/**
  * A [_Meaning] stores all the information necessary to find the declaration
  * referred to by a name in a namespace.
  */
 class _Meaning {
   /**
    * Which unit in the dependent library contains the declared entity.
    */
   final int unit;
 
   /**
@@ skipping 119 matching lines @@
 
     Map<String, _Meaning> aggregated = <String, _Meaning>{};
 
     for (int unitNum = 0; unitNum < unitUris.length; unitNum++) {
       String unitUri = unitUris[unitNum];
       UnlinkedPublicNamespace importedNamespace = getImportCached(unitUri);
       if (importedNamespace == null) {
         continue;
       }
       for (UnlinkedPublicName name in importedNamespace.names) {
-        aggregated.putIfAbsent(
-            name.name,
-            () => new _Meaning(
-                unitNum, name.kind, dependency, name.numTypeParameters));
+        aggregated.putIfAbsent(name.name, () {
+          if (name.kind == ReferenceKind.classOrEnum) {
+            Map<String, _Meaning> namespace = <String, _Meaning>{};
+            name.executables.forEach((executable) {
+              namespace[executable.name] = new _Meaning(unitNum,
+                  executable.kind, dependency, executable.numTypeParameters);
+            });
+            return new _ClassMeaning(
+                unitNum, dependency, name.numTypeParameters, namespace);
+          }
+          return new _Meaning(
+              unitNum, name.kind, dependency, name.numTypeParameters);
+        });
       }
     }
 
     dependencyToPublicNamespace.add(aggregated);
     return aggregated;
   }
 
   /**
    * Compute the export namespace for the library whose URI is reachable from
    * [definingUnit] via [relativeUri], by aggregating together public namespace
@@ skipping 33 matching lines @@
     return exportNamespace;
   }
 
   /**
    * Extract all the names defined in [unit] (which is the [unitNum]th unit in
    * the library being prelinked) and store them in [privateNamespace].
    * Excludes names introduced by `import` statements.
    */
   void extractPrivateNames(UnlinkedUnit unit, int unitNum) {
     for (UnlinkedClass cls in unit.classes) {
-      privateNamespace.putIfAbsent(
-          cls.name,
-          () => new _Meaning(unitNum, ReferenceKind.classOrEnum, 0,
-              cls.typeParameters.length));
+      privateNamespace.putIfAbsent(cls.name, () {
+        Map<String, _Meaning> namespace = <String, _Meaning>{};
+        cls.executables.forEach((executable) {
+          namespace[executable.name] = new _Meaning(
+              unitNum,
+              executable.kind == UnlinkedExecutableKind.constructor
+                  ? ReferenceKind.constructor
+                  : ReferenceKind.staticMethod,
+              0,
+              executable.typeParameters.length);
+        });
+        return new _ClassMeaning(
+            unitNum, 0, cls.typeParameters.length, namespace);
+      });
     }
     for (UnlinkedEnum enm in unit.enums) {
       privateNamespace.putIfAbsent(enm.name,
           () => new _Meaning(unitNum, ReferenceKind.classOrEnum, 0, 0));
     }
     for (UnlinkedExecutable executable in unit.executables) {
       privateNamespace.putIfAbsent(
           executable.name,
           () => new _Meaning(
               unitNum,
@@ skipping 104 matching lines @@
   LinkedUnitBuilder linkUnit(UnlinkedUnit unit) {
     if (unit == null) {
       return new LinkedUnitBuilder();
     }
     Map<int, Map<String, _Meaning>> prefixNamespaces =
         <int, Map<String, _Meaning>>{};
     List<LinkedReferenceBuilder> references = <LinkedReferenceBuilder>[];
     for (int i = 0; i < unit.references.length; i++) {
       UnlinkedReference reference = unit.references[i];
       Map<String, _Meaning> namespace;
-      if (reference.prefixReference != 0) {
+      if (reference.prefixReference == 0) {
+        namespace = privateNamespace;
+      } else {
         // Prefix references must always point backward.
         assert(reference.prefixReference < i);
         namespace = prefixNamespaces[reference.prefixReference];
         // Prefix references must always point to proper prefixes.
         assert(namespace != null);
-      } else {
-        namespace = privateNamespace;
       }
       _Meaning meaning = namespace[reference.name];
       if (meaning != null) {
         if (meaning is _PrefixMeaning) {
           prefixNamespaces[i] = meaning.namespace;
+        } else if (meaning is _ClassMeaning) {
+          prefixNamespaces[i] = meaning.namespace;
         }
         references.add(meaning.encodeReference());
       } else {
         references
             .add(new LinkedReferenceBuilder(kind: ReferenceKind.unresolved));
       }
     }
     return new LinkedUnitBuilder(references: references);
   }
 
@@ skipping 54 matching lines @@
    * [sourceUri] is also relative.
    */
   String resolveUri(String sourceUri, String relativeUri) {
     if (sourceUri == null) {
       return relativeUri;
     } else {
       return Uri.parse(sourceUri).resolve(relativeUri).toString();
     }
   }
 }