[Immediate] [Sema] Implemented Lazy Type Checking

Implements lazy type checking in Swift Immediate mode,
allowing functions to be type-checked as they are
executed.

Author: Zak Kent

include/swift/AST/TypeCheckRequests.h

@@ -2997,8 +2997,7 @@ class TypeCheckSourceFileRequest
   friend SimpleRequest;
 
   // Evaluation.
-  evaluator::SideEffect evaluate(Evaluator &evaluator, SourceFile *SF,
-                                 bool CheckFunctionBodies = true) const;
+  evaluator::SideEffect evaluate(Evaluator &evaluator, SourceFile *SF) const;
 
 public:
   // Separate caching.

include/swift/Basic/LangOptions.h

@@ -799,6 +799,9 @@ namespace swift {
 
     /// See \ref FrontendOptions.PrintFullConvention
     bool PrintFullConvention = false;
+
+    /// Defer typechecking of declarations to their use at runtime
+    bool DeferToRuntime = false;
   };
 
   /// Options for controlling the behavior of the Clang importer.

include/swift/SIL/SILDeclRef.h

@@ -294,7 +294,7 @@ struct SILDeclRef {
   bool hasAutoClosureExpr() const;
   bool hasFuncDecl() const;
 
-  ValueDecl *getDecl() const { return loc.get<ValueDecl *>(); }
+  ValueDecl *getDecl() const { return loc.dyn_cast<ValueDecl *>(); }
   AbstractClosureExpr *getAbstractClosureExpr() const {
     return loc.dyn_cast<AbstractClosureExpr *>();
   }

lib/Frontend/CompilerInvocation.cpp

@@ -1424,6 +1424,9 @@ static bool ParseTypeCheckerArgs(TypeCheckerOptions &Opts, ArgList &Args,
   if (Args.getLastArg(OPT_solver_disable_shrink))
     Opts.SolverDisableShrink = true;
 
+  if (FrontendOpts.RequestedAction == FrontendOptions::ActionType::Immediate)
+    Opts.DeferToRuntime = true;
+
   Opts.DebugGenericSignatures |= Args.hasArg(OPT_debug_generic_signatures);
 
   return HadError;

lib/FrontendTool/FrontendTool.cpp

@@ -843,10 +843,6 @@ bool swift::performCompileStepsPostSema(CompilerInstance &Instance,
         Instance.getPrimarySpecificPathsForWholeModuleOptimizationMode();
     SILOptions SILOpts = getSILOptions(PSPs);
     IRGenOptions irgenOpts = Invocation.getIRGenOptions();
-    if (Invocation.getFrontendOptions().RequestedAction ==
-        FrontendOptions::ActionType::Immediate) {
-      return RunImmediatelyFromAST(Instance) != -1;
-    }
     auto SM = performASTLowering(mod, Instance.getSILTypes(), SILOpts,
                                  &irgenOpts);
     return performCompileStepsPostSILGen(Instance, std::move(SM), mod, PSPs,
@@ -1368,13 +1364,15 @@ static bool performAction(CompilerInstance &Instance,
                                 [](CompilerInstance &Instance) {
                                   return Instance.getASTContext().hadError();
                                 });
+  case FrontendOptions::ActionType::Immediate: {
+    return RunImmediatelyFromAST(Instance) != -1;
+  }
   case FrontendOptions::ActionType::EmitSILGen:
   case FrontendOptions::ActionType::EmitSIBGen:
   case FrontendOptions::ActionType::EmitSIL:
   case FrontendOptions::ActionType::EmitSIB:
   case FrontendOptions::ActionType::EmitModuleOnly:
   case FrontendOptions::ActionType::MergeModules:
-  case FrontendOptions::ActionType::Immediate:
   case FrontendOptions::ActionType::EmitAssembly:
   case FrontendOptions::ActionType::EmitIRGen:
   case FrontendOptions::ActionType::EmitIR:

lib/Immediate/Immediate.cpp

@@ -596,7 +596,15 @@ class SwiftMaterializationUnit : public llvm::orc::MaterializationUnit {
     SILRefsToEmit Refs;
     for (auto &Sym : R->getRequestedSymbols()) {
       const auto &Source = Sources.storage->find(*Sym)->getValue();
-      Refs.push_back(Source.getSILDeclRef());
+      auto Ref = Source.getSILDeclRef();
+      if (auto *AFD = Ref.getAbstractFunctionDecl()) {
+        AFD->getTypecheckedBody();
+        if (CI.getASTContext().hadError()) {
+          R->failMaterialization();
+          return;
+        }
+      }
+      Refs.push_back(std::move(Ref));
     }
     auto SM = performASTLowering(CI, std::move(Refs));
     runSILDiagnosticPasses(*SM);
@@ -888,9 +896,11 @@ int swift::RunImmediately(CompilerInstance &CI, const ProcessCmdLine &CmdLine,
 }
 
 int swift::RunImmediatelyFromAST(CompilerInstance &CI) {
-
+  CI.performSema();
   auto &Context = CI.getASTContext();
-
+  if (Context.hadError()) {
+    return -1;
+  }
   const auto &Invocation = CI.getInvocation();
   const auto &FrontendOpts = Invocation.getFrontendOptions();
 

lib/SIL/IR/SILDeclRef.cpp

@@ -734,7 +734,7 @@ bool SILDeclRef::isSetter() const {
 }
 
 AbstractFunctionDecl *SILDeclRef::getAbstractFunctionDecl() const {
-  return dyn_cast<AbstractFunctionDecl>(getDecl());
+  return dyn_cast_or_null<AbstractFunctionDecl>(getDecl());
 }
 
 bool SILDeclRef::isInitAccessor() const {

lib/Sema/TypeChecker.cpp

@@ -260,8 +260,7 @@ void swift::performTypeChecking(SourceFile &SF) {
 }
 
 evaluator::SideEffect
-TypeCheckSourceFileRequest::evaluate(Evaluator &eval, SourceFile *SF,
-                                     bool CheckFunctionBodies) const {
+TypeCheckSourceFileRequest::evaluate(Evaluator &eval, SourceFile *SF) const {
   assert(SF && "Source file cannot be null!");
   assert(SF->ASTStage != SourceFile::TypeChecked &&
          "Should not be re-typechecking this file!");
@@ -307,7 +306,7 @@ TypeCheckSourceFileRequest::evaluate(Evaluator &eval, SourceFile *SF,
         }
       }
     }
-    if (CheckFunctionBodies) {
+    if (!Ctx.TypeCheckerOpts.DeferToRuntime) {
       typeCheckDelayedFunctions(*SF);
     }
   }