Merge pull request #994 from swiftwasm/master

[pull] swiftwasm from master

Author: MaxDesiatov

docs/TypeChecker.rst

@@ -718,7 +718,7 @@ Locators
 During constraint generation and solving, numerous constraints are
 created, broken apart, and solved. During constraint application as
 well as during diagnostics emission, it is important to track the
-relationship between the constraints and the actual expressions from
+relationship between the constraints and the actual AST nodes from
 which they originally came. For example, consider the following type
 checking problem::
 
@@ -754,16 +754,16 @@ functions was selected to perform the conversion, so that conversion
 function can be called by constraint application if all else succeeds.
 
 *Locators* address both issues by tracking the location and derivation
-of constraints. Each locator is anchored at a specific expression,
-i.e., the function application ``f(10.5, x)``, and contains a path of
-zero or more derivation steps from that anchor. For example, the
-"``T(f)`` ==Fn ``T0 -> T1``" constraint has a locator that is
-anchored at the function application and a path with the "apply
-function" derivation step, meaning that this is the function being
-applied. Similarly, the "``(T2, X) <c T0`` constraint has a
-locator anchored at the function application and a path with the
-"apply argument" derivation step, meaning that this is the argument
-to the function.
+of constraints. Each locator is anchored at a specific AST node
+(expression, pattern, declaration etc.) i.e., the function application
+``f(10.5, x)``, and contains a path of zero or more derivation steps
+from that anchor. For example, the "``T(f)`` ==Fn ``T0 -> T1``"
+constraint has a locator that is anchored at the function application
+and a path with the "apply function" derivation step, meaning that
+this is the function being applied. Similarly, the "``(T2, X) <c T0``
+constraint has a locator anchored at the function application and a
+path with the "apply argument" derivation step, meaning that this is
+the argument to the function.
 
 When constraints are simplified, the resulting constraints have
 locators with longer paths. For example, when a conversion constraint between two
@@ -812,15 +812,15 @@ Locators provide the derivation of location information that follows
 the path of the solver, and can be used to query and recover the
 important decisions made by the solver. However, the locators
 determined by the solver may not directly refer to the most specific
-expression for the purposes of identifying the corresponding source
+AST node for the purposes of identifying the corresponding source
 location. For example, the failed constraint "``Int`` conforms to
 ``ExpressibleByFloatLiteral``" can most specifically by centered on the
 floating-point literal ``10.5``, but its locator is::
 
   function application -> apply argument -> tuple element #0
 
 The process of locator simplification maps a locator to its most
-specific expression. Essentially, it starts at the anchor of the
+specific AST node. Essentially, it starts at the anchor of the
 locator (in this case, the application ``f(10.5, x)``) and then walks
 the path, matching derivation steps to subexpressions. The "function
 application" derivation step extracts the argument (``(10.5,

include/swift/AST/ASTContext.h

@@ -238,10 +238,10 @@ class ASTContext final {
   UnifiedStatsReporter *Stats = nullptr;
 
   /// The language options used for translation.
-  LangOptions &LangOpts;
+  const LangOptions &LangOpts;
 
   /// The type checker options.
-  TypeCheckerOptions &TypeCheckerOpts;
+  const TypeCheckerOptions &TypeCheckerOpts;
 
   /// The search path options used by this AST context.
   SearchPathOptions &SearchPathOpts;

include/swift/AST/Decl.h

@@ -575,7 +575,7 @@ class alignas(1 << DeclAlignInBits) Decl {
     HasAnyUnavailableValues : 1
   );
 
-  SWIFT_INLINE_BITFIELD(ModuleDecl, TypeDecl, 1+1+1+1+1+1+1+1,
+  SWIFT_INLINE_BITFIELD(ModuleDecl, TypeDecl, 1+1+1+1+1+1+1+1+1,
     /// If the module was or is being compiled with `-enable-testing`.
     TestingEnabled : 1,
 
@@ -601,7 +601,10 @@ class alignas(1 << DeclAlignInBits) Decl {
 
     /// Whether the module was imported from Clang (or, someday, maybe another
     /// language).
-    IsNonSwiftModule : 1
+    IsNonSwiftModule : 1,
+
+    /// Whether this module is the main module.
+    IsMainModule : 1
   );
 
   SWIFT_INLINE_BITFIELD(PrecedenceGroupDecl, Decl, 1+2,

include/swift/AST/DiagnosticsFrontend.def

@@ -375,5 +375,10 @@ ERROR(expectation_missing_opening_braces,none,
 ERROR(expectation_missing_closing_braces,none,
       "didn't find '}}' to match '{{' in expectation", ())
 
+WARNING(module_incompatible_with_skip_function_bodies,none,
+        "module '%0' cannot be built with "
+        "-experimental-skip-non-inlinable-function-bodies; this option has "
+        "been automatically disabled", (StringRef))
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

include/swift/AST/Module.h

@@ -347,6 +347,13 @@ class ModuleDecl : public DeclContext, public TypeDecl {
     return new (ctx) ModuleDecl(name, ctx, importInfo);
   }
 
+  static ModuleDecl *
+  createMainModule(ASTContext &ctx, Identifier name, ImplicitImportInfo iinfo) {
+    auto *Mod = ModuleDecl::create(name, ctx, iinfo);
+    Mod->Bits.ModuleDecl.IsMainModule = true;
+    return Mod;
+  }
+
   using Decl::getASTContext;
 
   /// Retrieves information about which modules are implicitly imported by
@@ -542,6 +549,10 @@ class ModuleDecl : public DeclContext, public TypeDecl {
     Bits.ModuleDecl.IsNonSwiftModule = flag;
   }
 
+  bool isMainModule() const {
+    return Bits.ModuleDecl.IsMainModule;
+  }
+
   /// Retrieve the top-level module. If this module is already top-level, this
   /// returns itself. If this is a submodule such as \c Foo.Bar.Baz, this
   /// returns the module \c Foo.

include/swift/AST/PlatformKind.h

@@ -54,11 +54,11 @@ StringRef prettyPlatformString(PlatformKind platform);
 /// If ForTargetVariant is true then for zippered builds the target-variant
 /// triple will be used rather than the target to determine whether the
 /// platform is active.
-bool isPlatformActive(PlatformKind Platform, LangOptions &LangOpts,
+bool isPlatformActive(PlatformKind Platform, const LangOptions &LangOpts,
                       bool ForTargetVariant = false);
 
 /// Returns the target platform for the given language options.
-PlatformKind targetPlatform(LangOptions &LangOpts);
+PlatformKind targetPlatform(const LangOptions &LangOpts);
 
 /// Returns true when availability attributes from the "parent" platform
 /// should also apply to the "child" platform for declarations without

include/swift/AST/SILGenRequests.h

@@ -81,19 +81,16 @@ struct SILGenDescriptor {
   /// If the module or file contains SIL that needs parsing, returns the file
   /// to be parsed, or \c nullptr if parsing isn't required.
   SourceFile *getSourceFileToParse() const;
-
-  /// Whether the SIL is being emitted for a whole module.
-  bool isWholeModule() const;
 };
 
 void simple_display(llvm::raw_ostream &out, const SILGenDescriptor &d);
 
 SourceLoc extractNearestSourceLoc(const SILGenDescriptor &desc);
 
-class SILGenSourceFileRequest :
-    public SimpleRequest<SILGenSourceFileRequest,
-                         std::unique_ptr<SILModule>(SILGenDescriptor),
-                         RequestFlags::Uncached|RequestFlags::DependencySource> {
+class SILGenerationRequest
+    : public SimpleRequest<
+          SILGenerationRequest, std::unique_ptr<SILModule>(SILGenDescriptor),
+          RequestFlags::Uncached | RequestFlags::DependencySource> {
 public:
   using SimpleRequest::SimpleRequest;
 
@@ -104,33 +101,12 @@ class SILGenSourceFileRequest :
   std::unique_ptr<SILModule>
   evaluate(Evaluator &evaluator, SILGenDescriptor desc) const;
 
-public:
-  bool isCached() const { return true; }
-
 public:
   // Incremental dependencies.
   evaluator::DependencySource
   readDependencySource(const evaluator::DependencyCollector &) const;
 };
 
-class SILGenWholeModuleRequest :
-    public SimpleRequest<SILGenWholeModuleRequest,
-                         std::unique_ptr<SILModule>(SILGenDescriptor),
-                         RequestFlags::Uncached> {
-public:
-  using SimpleRequest::SimpleRequest;
-
-private:
-  friend SimpleRequest;
-
-  // Evaluation.
-  std::unique_ptr<SILModule>
-  evaluate(Evaluator &evaluator, SILGenDescriptor desc) const;
-
-public:
-  bool isCached() const { return true; }
-};
-
 /// Parses a .sil file into a SILModule.
 class ParseSILModuleRequest
     : public SimpleRequest<ParseSILModuleRequest,

include/swift/AST/SILGenTypeIDZone.def

@@ -14,10 +14,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-SWIFT_REQUEST(SILGen, SILGenSourceFileRequest,
-              std::unique_ptr<SILModule>(SILGenDescriptor),
-              Uncached, NoLocationInfo)
-SWIFT_REQUEST(SILGen, SILGenWholeModuleRequest,
+SWIFT_REQUEST(SILGen, SILGenerationRequest,
               std::unique_ptr<SILModule>(SILGenDescriptor),
               Uncached, NoLocationInfo)
 SWIFT_REQUEST(SILGen, ParseSILModuleRequest,

include/swift/Basic/LLVM.h

@@ -34,7 +34,9 @@ namespace llvm {
   class Twine;
   template <typename T> class SmallPtrSetImpl;
   template <typename T, unsigned N> class SmallPtrSet;
+#if !defined(swiftCore_EXPORTS)
   template <typename T> class SmallVectorImpl;
+#endif
   template <typename T, unsigned N> class SmallVector;
   template <unsigned N> class SmallString;
   template <typename T, unsigned N> class SmallSetVector;
@@ -52,7 +54,9 @@ namespace llvm {
   class raw_ostream;
   class APInt;
   class APFloat;
+#if !defined(swiftCore_EXPORTS)
   template <typename Fn> class function_ref;
+#endif
 } // end namespace llvm
 
 
@@ -79,7 +83,9 @@ namespace swift {
   using llvm::SmallSetVector;
   using llvm::SmallString;
   using llvm::SmallVector;
+#if !defined(swiftCore_EXPORTS)
   using llvm::SmallVectorImpl;
+#endif
   using llvm::StringLiteral;
   using llvm::StringRef;
   using llvm::TinyPtrVector;
@@ -88,7 +94,9 @@ namespace swift {
   // Other common classes.
   using llvm::APFloat;
   using llvm::APInt;
+#if !defined(swiftCore_EXPORTS)
   using llvm::function_ref;
+#endif
   using llvm::NoneType;
   using llvm::raw_ostream;
 } // end namespace swift

include/swift/Demangling/TypeDecoder.h

@@ -896,7 +896,7 @@ class TypeDecoder {
 private:
   template <typename T>
   bool decodeImplFunctionPart(Demangle::NodePointer node,
-                              SmallVectorImpl<T> &results) {
+                              llvm::SmallVectorImpl<T> &results) {
     if (node->getNumChildren() != 2)
       return true;
 
@@ -919,7 +919,7 @@ class TypeDecoder {
 
   bool decodeImplFunctionParam(
       Demangle::NodePointer node,
-      SmallVectorImpl<ImplFunctionParam<BuiltType>> &results) {
+      llvm::SmallVectorImpl<ImplFunctionParam<BuiltType>> &results) {
     // Children: `convention, differentiability?, type`
     if (node->getNumChildren() != 2 && node->getNumChildren() != 3)
       return true;
@@ -1021,7 +1021,7 @@ class TypeDecoder {
 
   bool decodeMangledFunctionInputType(
       Demangle::NodePointer node,
-      SmallVectorImpl<FunctionParam<BuiltType>> &params,
+      llvm::SmallVectorImpl<FunctionParam<BuiltType>> &params,
       bool &hasParamFlags) {
     // Look through a couple of sugar nodes.
     if (node->getKind() == NodeKind::Type ||

include/swift/Parse/Parser.h

@@ -1359,8 +1359,7 @@ class Parser {
   ParserResult<Pattern> parsePatternTuple();
 
   ParserResult<Pattern>
-  parseOptionalPatternTypeAnnotation(ParserResult<Pattern> P,
-                                     bool isOptional);
+  parseOptionalPatternTypeAnnotation(ParserResult<Pattern> P);
   ParserResult<Pattern> parseMatchingPattern(bool isExprBasic);
   ParserResult<Pattern> parseMatchingPatternAsLetOrVar(bool isLet,
                                                        SourceLoc VarLoc,

include/swift/SIL/SILModule.h

@@ -107,8 +107,6 @@ enum class SILStage {
 /// when a Swift compilation context is lowered to SIL.
 class SILModule {
   friend class SILFunctionBuilder;
-  friend class SILGenSourceFileRequest;
-  friend class SILGenWholeModuleRequest;
 
 public:
   using FunctionListType = llvm::ilist<SILFunction>;
@@ -262,10 +260,6 @@ class SILModule {
   /// The indexed profile data to be used for PGO, or nullptr.
   std::unique_ptr<llvm::IndexedInstrProfReader> PGOReader;
 
-  /// True if this SILModule really contains the whole module, i.e.
-  /// optimizations can assume that they see the whole module.
-  bool wholeModule;
-
   /// The options passed into this SILModule.
   const SILOptions &Options;
 
@@ -280,11 +274,8 @@ class SILModule {
   /// invalidation message is sent.
   llvm::SetVector<DeleteNotificationHandler*> NotificationHandlers;
 
-  // Intentionally marked private so that we need to use 'constructSIL()'
-  // to construct a SILModule.
-  SILModule(ModuleDecl *M, Lowering::TypeConverter &TC,
-            const SILOptions &Options, const DeclContext *associatedDC,
-            bool wholeModule);
+  SILModule(llvm::PointerUnion<FileUnit *, ModuleDecl *> context,
+            Lowering::TypeConverter &TC, const SILOptions &Options);
 
   SILModule(const SILModule&) = delete;
   void operator=(const SILModule&) = delete;
@@ -355,47 +346,38 @@ class SILModule {
   /// Erase a global SIL variable from the module.
   void eraseGlobalVariable(SILGlobalVariable *G);
 
-  /// Construct a SIL module from an AST module.
-  ///
-  /// The module will be constructed in the Raw stage. The provided AST module
-  /// should contain source files.
+  /// Create and return an empty SIL module suitable for generating or parsing
+  /// SIL into.
   ///
-  /// If a source file is provided, SIL will only be emitted for decls in that
-  /// source file.
-  static std::unique_ptr<SILModule>
-  constructSIL(ModuleDecl *M, Lowering::TypeConverter &TC,
-               const SILOptions &Options, FileUnit *sf = nullptr);
-
-  /// Create and return an empty SIL module that we can
-  /// later parse SIL bodies directly into, without converting from an AST.
+  /// \param context The associated decl context. This should be a FileUnit in
+  /// single-file mode, and a ModuleDecl in whole-module mode.
   static std::unique_ptr<SILModule>
-  createEmptyModule(ModuleDecl *M, Lowering::TypeConverter &TC,
-                    const SILOptions &Options,
-                    bool WholeModule = false);
+  createEmptyModule(llvm::PointerUnion<FileUnit *, ModuleDecl *> context,
+                    Lowering::TypeConverter &TC, const SILOptions &Options);
 
   /// Get the Swift module associated with this SIL module.
   ModuleDecl *getSwiftModule() const { return TheSwiftModule; }
   /// Get the AST context used for type uniquing etc. by this SIL module.
   ASTContext &getASTContext() const;
   SourceManager &getSourceManager() const { return getASTContext().SourceMgr; }
 
-  /// Get the Swift DeclContext associated with this SIL module.
+  /// Get the Swift DeclContext associated with this SIL module. This is never
+  /// null.
   ///
   /// All AST declarations within this context are assumed to have been fully
   /// processed as part of generating this module. This allows certain passes
   /// to make additional assumptions about these declarations.
   ///
   /// If this is the same as TheSwiftModule, the entire module is being
-  /// compiled as a single unit. If this is null, no context-based assumptions
-  /// can be made.
+  /// compiled as a single unit.
   const DeclContext *getAssociatedContext() const {
     return AssociatedDeclContext;
   }
 
   /// Returns true if this SILModule really contains the whole module, i.e.
   /// optimizations can assume that they see the whole module.
   bool isWholeModule() const {
-    return wholeModule;
+    return isa<ModuleDecl>(AssociatedDeclContext);
   }
 
   bool isStdlibModule() const;

lib/AST/ASTPrinter.cpp

@@ -2613,18 +2613,10 @@ void PrintAST::visitVarDecl(VarDecl *decl) {
   Printer << ": ";
   TypeLoc tyLoc;
   if (auto *repr = decl->getTypeReprOrParentPatternTypeRepr()) {
-    // Workaround for if-let statements. The parser creates a `OptionalTypeRepr`
-    // even though the user-written declared type for the if-let variable
-    // is non-optional. Get the non-optional type so we can print it correctly.
-    if (auto *optRepr = dyn_cast<OptionalTypeRepr>(repr)) {
-      if (type && !isa<OptionalType>(type.getPointer())) {
-        repr = optRepr->getBase();
-      }
-    }
     tyLoc = TypeLoc(repr, type);
-  } else
+  } else {
     tyLoc = TypeLoc::withoutLoc(type);
-
+  }
   Printer.printDeclResultTypePre(decl, tyLoc);
 
   // HACK: When printing result types for vars with opaque result types,