Merge pull request #62809 from xedin/enable-result-builder-ast-transform-by-default-with-old-impl-5.8

[5.8][TypeChecker] Enable result builder AST transform by default

Author: xedin

include/swift/AST/Decl.h

@@ -1969,6 +1969,10 @@ class PatternBindingDecl final : public Decl,
     getMutablePatternList()[i].setInit(E);
   }
 
+  void setOriginalInit(unsigned i, Expr *E) {
+    getMutablePatternList()[i].setOriginalInit(E);
+  }
+
   Pattern *getPattern(unsigned i) const {
     return getPatternList()[i].getPattern();
   }

include/swift/Basic/Features.def

@@ -104,7 +104,6 @@ EXPERIMENTAL_FEATURE(FlowSensitiveConcurrencyCaptures, false)
 EXPERIMENTAL_FEATURE(MoveOnly, false)
 EXPERIMENTAL_FEATURE(OneWayClosureParameters, false)
 EXPERIMENTAL_FEATURE(TypeWitnessSystemInference, false)
-EXPERIMENTAL_FEATURE(ResultBuilderASTTransform, true)
 EXPERIMENTAL_FEATURE(LayoutPrespecialization, false)
 EXPERIMENTAL_FEATURE(ModuleInterfaceExportAs, true)
 

include/swift/Sema/ConstraintSystem.h

@@ -6460,6 +6460,10 @@ class ConjunctionElement {
     Element->print(Out, SM, indent);
   }
 
+  /// Returns \c false if this conjunction element is known not to contain the
+  /// code compleiton token.
+  bool mightContainCodeCompletionToken(const ConstraintSystem &cs) const;
+
 private:
   /// Find type variables referenced by this conjunction element.
   /// If this is a closure body element, it would look inside \c ASTNode.

lib/AST/ASTPrinter.cpp

@@ -3118,10 +3118,6 @@ static bool usesFeatureOneWayClosureParameters(Decl *decl) {
   return false;
 }
 
-static bool usesFeatureResultBuilderASTTransform(Decl *decl) {
-  return false;
-}
-
 static bool usesFeatureTypeWitnessSystemInference(Decl *decl) {
   return false;
 }

lib/AST/Decl.cpp

@@ -1529,6 +1529,7 @@ PatternBindingDecl *PatternBindingDecl::createImplicit(
                         Pat, /*EqualLoc*/ SourceLoc(), nullptr, Parent);
   Result->setImplicit();
   Result->setInit(0, E);
+  Result->setOriginalInit(0, E);
   return Result;
 }
 

lib/IDE/CodeCompletionResultType.cpp

@@ -184,7 +184,7 @@ const USRBasedType *USRBasedType::fromType(Type Ty, USRBasedTypeArena &Arena) {
   Ty = Ty->getCanonicalType();
 
   // For opaque types like 'some View', consider them equivalent to 'View'.
-  if (auto OpaqueType = Ty->getAs<OpaqueTypeArchetypeType>()) {
+  if (auto OpaqueType = Ty->getAs<ArchetypeType>()) {
     if (auto Existential = OpaqueType->getExistentialType()) {
       Ty = Existential;
     }

lib/Sema/BuilderTransform.cpp

@@ -959,8 +959,8 @@ class ResultBuilderTransform
   VarDecl *captureExpr(Expr *expr, SmallVectorImpl<ASTNode> &container) {
     auto *var = builder.buildVar(expr->getStartLoc());
     Pattern *pattern = NamedPattern::createImplicit(ctx, var);
-    auto *PB = PatternBindingDecl::createImplicit(ctx, StaticSpellingKind::None,
-                                                  pattern, expr, dc);
+    auto *PB = PatternBindingDecl::createImplicit(
+        ctx, StaticSpellingKind::None, pattern, expr, dc, var->getStartLoc());
     return recordVar(PB, container);
   }
 
@@ -972,7 +972,8 @@ class ResultBuilderTransform
         ctx, NamedPattern::createImplicit(ctx, var),
         type ? type : PlaceholderType::get(ctx, var));
     auto *PB = PatternBindingDecl::createImplicit(
-        ctx, StaticSpellingKind::None, placeholder, /*init=*/initExpr, dc);
+        ctx, StaticSpellingKind::None, placeholder, /*init=*/initExpr, dc,
+        var->getStartLoc());
     return recordVar(PB, container);
   }
 
@@ -1058,11 +1059,20 @@ class ResultBuilderTransform
                                {Identifier()});
     }
 
-    auto *capture = captureExpr(expr, newBody);
-    // A reference to the synthesized variable is passed as an argument
-    // to buildBlock.
-    buildBlockArguments.push_back(
-        builder.buildVarRef(capture, element.getStartLoc()));
+    if (isa<CodeCompletionExpr>(expr)) {
+      // Insert the CodeCompletionExpr directly into the buildBlock call. That
+      // way, we can extract the contextual type of the code completion token
+      // to rank code completion items that match the type expected by
+      // buildBlock higher.
+      buildBlockArguments.push_back(expr);
+    } else {
+      auto *capture = captureExpr(expr, newBody);
+      // A reference to the synthesized variable is passed as an argument
+      // to buildBlock.
+      buildBlockArguments.push_back(
+          builder.buildVarRef(capture, element.getStartLoc()));
+    }
+
     return None;
   }
 
@@ -2459,7 +2469,9 @@ ConstraintSystem::matchResultBuilder(AnyFunctionRef fn, Type builderType,
     return None;
   }
 
-  if (Context.LangOpts.hasFeature(Feature::ResultBuilderASTTransform)) {
+  auto disableASTTransform = [&](NominalTypeDecl *builder) { return false; };
+
+  if (!disableASTTransform(builder)) {
     auto transformedBody = getBuilderTransformedBody(fn, builder);
     // If this builder transform has not yet been applied to this function,
     // let's do it and cache the result.
@@ -2517,7 +2529,7 @@ ConstraintSystem::matchResultBuilder(AnyFunctionRef fn, Type builderType,
       auto &log = llvm::errs();
       auto indent = solverState ? solverState->getCurrentIndent() : 0;
       log.indent(indent) << "------- Transfomed Body -------\n";
-      transformedBody->second->dump(log);
+      transformedBody->second->dump(log, &getASTContext(), indent);
       log << '\n';
     }
 

lib/Sema/CSStep.cpp

@@ -880,6 +880,17 @@ bool ConjunctionStep::attempt(const ConjunctionElement &element) {
     CS.Timer.emplace(element.getLocator(), CS);
   }
 
+  assert(!ModifiedOptions.hasValue() &&
+         "Previously modified options should have been restored in resume");
+  if (CS.isForCodeCompletion() &&
+      !element.mightContainCodeCompletionToken(CS)) {
+    ModifiedOptions.emplace(CS.Options);
+    // If we know that this conjunction element doesn't contain the code
+    // completion token, type check it in normal mode without any special
+    // behavior that is intended for the code completion token.
+    CS.Options -= ConstraintSystemFlags::ForCodeCompletion;
+  }
+
   auto success = element.attempt(CS);
 
   // If element attempt has failed, mark whole conjunction
@@ -891,6 +902,9 @@ bool ConjunctionStep::attempt(const ConjunctionElement &element) {
 }
 
 StepResult ConjunctionStep::resume(bool prevFailed) {
+  // Restore the old ConstraintSystemOptions if 'attempt' modified them.
+  ModifiedOptions.reset();
+
   // Return from the follow-up splitter step that
   // attempted to apply information gained from the
   // isolated constraint to the outer context.

lib/Sema/CSStep.h

@@ -966,6 +966,11 @@ class ConjunctionStep : public BindingStep<ConjunctionElementProducer> {
   /// in isolated mode.
   SmallVector<Solution, 4> IsolatedSolutions;
 
+  /// If \c ConjunctionStep::attempt modified the constraint system options,
+  /// it will store the original options in this \c llvm::SaveAndRestore.
+  /// Upon \c resume, these values will be restored.
+  Optional<llvm::SaveAndRestore<ConstraintSystemOptions>> ModifiedOptions;
+
 public:
   ConjunctionStep(ConstraintSystem &cs, Constraint *conjunction,
                   SmallVectorImpl<Solution> &solutions)

lib/Sema/CSSyntacticElement.cpp

@@ -1290,13 +1290,17 @@ class SyntacticElementSolutionApplication
   virtual ~SyntacticElementSolutionApplication() {}
 
 private:
-  ASTNode visit(Stmt *S) {
+
+  ASTNode visit(Stmt *S, bool performSyntacticDiagnostics = true) {
     auto rewritten = ASTVisitor::visit(S);
     if (!rewritten)
       return {};
 
-    if (auto *stmt = getAsStmt(rewritten))
-      performStmtDiagnostics(stmt, context.getAsDeclContext());
+    if (performSyntacticDiagnostics) {
+      if (auto *stmt = getAsStmt(rewritten)) {
+        performStmtDiagnostics(stmt, context.getAsDeclContext());
+      }
+    }
 
     return rewritten;
   }
@@ -1819,8 +1823,9 @@ class ResultBuilderRewriter : public SyntacticElementSolutionApplication {
 
 private:
   ASTNode visitDoStmt(DoStmt *doStmt) override {
-    if (auto transformed = transformDo(doStmt))
-      return visit(transformed.get());
+    if (auto transformed = transformDo(doStmt)) {
+      return visit(transformed.get(), /*performSyntacticDiagnostics=*/false);
+    }
 
     auto newBody = visit(doStmt->getBody());
     if (!newBody)
@@ -2111,11 +2116,9 @@ SolutionApplicationToFunctionResult ConstraintSystem::applySolution(
   if (auto transform = solution.getAppliedBuilderTransform(fn)) {
     NullablePtr<BraceStmt> newBody;
 
-    if (Context.LangOpts.hasFeature(Feature::ResultBuilderASTTransform)) {
-      BraceStmt *transformedBody =
-          const_cast<BraceStmt *>(transform->transformedBody.get());
-
-      fn.setParsedBody(transformedBody, /*singleExpression=*/false);
+    if (auto transformedBody = transform->transformedBody) {
+      fn.setParsedBody(const_cast<BraceStmt *>(transformedBody.get()),
+                       /*singleExpression=*/false);
 
       ResultBuilderRewriter rewriter(solution, fn, *transform, rewriteTarget);
 
@@ -2203,6 +2206,21 @@ bool ConstraintSystem::applySolutionToBody(Solution &solution,
   return false;
 }
 
+bool ConjunctionElement::mightContainCodeCompletionToken(
+    const ConstraintSystem &cs) const {
+  if (Element->getKind() == ConstraintKind::SyntacticElement) {
+    if (Element->getSyntacticElement().getSourceRange().isInvalid()) {
+      return true;
+    } else {
+      return cs.containsIDEInspectionTarget(Element->getSyntacticElement());
+    }
+  } else {
+    // All other constraint kinds are not handled yet. Assume that they might
+    // contain the code completion token.
+    return true;
+  }
+}
+
 void ConjunctionElement::findReferencedVariables(
     ConstraintSystem &cs, SmallPtrSetImpl<TypeVariableType *> &typeVars) const {
   auto referencedVars = Element->getTypeVariables();

lib/Sema/TypeCheckConstraints.cpp

@@ -998,11 +998,6 @@ static Type replaceArchetypesWithTypeVariables(ConstraintSystem &cs,
         return found->second;
 
       if (auto archetypeType = dyn_cast<ArchetypeType>(origType)) {
-        // We leave opaque types and their nested associated types alone here.
-        // They're globally available.
-        if (isa<OpaqueTypeArchetypeType>(archetypeType))
-          return origType;
-
         auto root = archetypeType->getRoot();
         // For other nested types, fail here so the default logic in subst()
         // for nested types applies.
@@ -1033,7 +1028,8 @@ static Type replaceArchetypesWithTypeVariables(ConstraintSystem &cs,
       types[origType] = replacement;
       return replacement;
     },
-    MakeAbstractConformanceForGenericType());
+    MakeAbstractConformanceForGenericType(),
+    SubstFlags::SubstituteOpaqueArchetypes);
 }
 
 bool TypeChecker::typesSatisfyConstraint(Type type1, Type type2,