Store parts in Kernel Library, resynthesize parts in Analyzer.

pkg/kernel/lib/ast.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.
 
 /// -----------------------------------------------------------------------
 ///                           ERROR HANDLING
 /// -----------------------------------------------------------------------
 ///
 /// As a rule of thumb, errors that can be detected statically are handled by
 /// the frontend, typically by translating the erroneous code into a 'throw' or
@@ skipping 251 matching lines @@
   /// other than [ClassLevel.Body].  Members in an external library have no
   /// body, but have their typed interface present.
   ///
   /// If the libary is non-external, then its classes are at [ClassLevel.Body]
   /// and all members are loaded.
   bool isExternal;
 
   String name;
   final List<Expression> annotations;
   final List<LibraryDependency> dependencies;
+  final List<LibraryPart> parts;

[Siggi Cherem (dart-lang), 2017/08/02 23:06:23]

should we add @informational to this field?

[scheglov, 2017/08/03 00:16:35]

Acknowledged.

   final List<Typedef> typedefs;
   final List<Class> classes;
   final List<Procedure> procedures;
   final List<Field> fields;
 
   Library(this.importUri,
       {this.name,
       this.isExternal: false,
       List<Expression> annotations,
       List<LibraryDependency> dependencies,
+      List<LibraryPart> parts,
       List<Typedef> typedefs,
       List<Class> classes,
       List<Procedure> procedures,
       List<Field> fields,
       this.fileUri,
       Reference reference})
       : this.annotations = annotations ?? <Expression>[],
         this.dependencies = dependencies ?? <LibraryDependency>[],
+        this.parts = parts ?? <LibraryPart>[],
         this.typedefs = typedefs ?? <Typedef>[],
         this.classes = classes ?? <Class>[],
         this.procedures = procedures ?? <Procedure>[],
         this.fields = fields ?? <Field>[],
         super(reference) {
     setParents(this.dependencies, this);
+    setParents(this.parts, this);
     setParents(this.typedefs, this);
     setParents(this.classes, this);
     setParents(this.procedures, this);
     setParents(this.fields, this);
   }
 
   /// Returns the top-level fields and procedures defined in this library.
   ///
   /// This getter is for convenience, not efficiency.  Consider manually
   /// iterating the members to speed up code in production.
@@ skipping 40 matching lines @@
     for (var class_ in classes) {
       canonicalName.getChild(class_.name).bindTo(class_.reference);
       class_.computeCanonicalNames();
     }
   }
 
   void addDependency(LibraryDependency node) {
     dependencies.add(node..parent = this);
   }
 
+  void addPart(LibraryPart node) {
+    parts.add(node..parent = this);
+  }
+
   accept(TreeVisitor v) => v.visitLibrary(this);
 
   visitChildren(Visitor v) {
     visitList(dependencies, v);
+    visitList(parts, v);
     visitList(typedefs, v);
     visitList(classes, v);
     visitList(procedures, v);
     visitList(fields, v);
   }
 
   transformChildren(Transformer v) {
     transformList(dependencies, v, this);
     transformList(typedefs, v, this);
     transformList(classes, v, this);
@@ skipping 86 matching lines @@
     visitList(annotations, v);
     visitList(combinators, v);
   }
 
   transformChildren(Transformer v) {
     transformList(annotations, v, this);
     transformList(combinators, v, this);
   }
 }
 
+/// A part declaration in a library.
+///
+///     part <url>;
+///
+/// optionally with metadata.
+class LibraryPart extends TreeNode {
+  final List<Expression> annotations;
+  final String fileUri;
+
+  LibraryPart(List<Expression> annotations, String fileUri)
+      : this.byReference(annotations, fileUri);
+
+  LibraryPart.byReference(this.annotations, this.fileUri) {
+    setParents(annotations, this);
+  }
+
+  void addAnnotation(Expression annotation) {
+    annotations.add(annotation..parent = this);
+  }
+
+  accept(TreeVisitor v) => v.visitLibraryPart(this);
+
+  visitChildren(Visitor v) {
+    visitList(annotations, v);
+  }
+
+  transformChildren(Transformer v) {
+    transformList(annotations, v, this);
+  }
+}
+
 /// A `show` or `hide` clause for an import or export.
 class Combinator extends TreeNode {
   bool isShow;
   final List<String> names;
 
   LibraryDependency get dependency => parent;
 
   Combinator(this.isShow, this.names);
   Combinator.show(this.names) : isShow = true;
   Combinator.hide(this.names) : isShow = false;
@@ skipping 4215 matching lines @@
   if (typedef_.canonicalName == null) {
     throw '$typedef_ has no canonical name';
   }
   return typedef_.canonicalName;
 }
 
 /// Annotation describing information which is not part of Dart semantics; in
 /// other words, if this information (or any information it refers to) changes,
 /// static analysis and runtime behavior of the library are unaffected.
 const informative = null;