Rebase SILScope generation on top of ASTScope

Author: adrian-prantl

include/swift/AST/ASTScope.h

@@ -78,6 +78,10 @@ class GenericContext;
 class DeclName;
 class StmtConditionElement;
 
+namespace Lowering {
+class SILGenFunction;
+}
+
 namespace ast_scope {
 class ASTScopeImpl;
 class GenericTypeOrExtensionScope;
@@ -129,6 +133,7 @@ class ASTScopeImpl : public ASTAllocated<ASTScopeImpl> {
   friend class IterableTypeBodyPortion;
   friend class ScopeCreator;
   friend class ASTSourceFileScope;
+  friend class Lowering::SILGenFunction;
 
 #pragma mark - tree state
 protected:
@@ -273,6 +278,10 @@ class ASTScopeImpl : public ASTAllocated<ASTScopeImpl> {
   static std::pair<CaseStmt *, CaseStmt *>
   lookupFallthroughSourceAndDest(SourceFile *sourceFile, SourceLoc loc);
 
+  /// Scopes that cannot bind variables may set this to true to create more
+  /// compact scope tree in the debug info.
+  virtual bool ignoreInDebugInfo() const { return false; }
+
 #pragma mark - - lookup- starting point
 private:
   static const ASTScopeImpl *findStartingScopeForLookup(SourceFile *,
@@ -777,6 +786,7 @@ class ParameterListScope final : public ASTScopeImpl {
   getSourceRangeOfThisASTNode(bool omitAssertions = false) const override;
 
   NullablePtr<const void> addressForPrinting() const override { return params; }
+  bool ignoreInDebugInfo() const override { return true; }
 };
 
 /// Body of functions, methods, constructors, destructors and accessors.
@@ -799,6 +809,7 @@ class FunctionBodyScope : public ASTScopeImpl {
   getSourceRangeOfThisASTNode(bool omitAssertions = false) const override;
   virtual NullablePtr<Decl> getDeclIfAny() const override { return decl; }
   Decl *getDecl() const { return decl; }
+  bool ignoreInDebugInfo() const override { return true; }
 
 protected:
   bool lookupLocalsOrMembers(DeclConsumer) const override;
@@ -825,6 +836,7 @@ class DefaultArgumentInitializerScope final : public ASTScopeImpl {
   getSourceRangeOfThisASTNode(bool omitAssertions = false) const override;
   virtual NullablePtr<Decl> getDeclIfAny() const override { return decl; }
   Decl *getDecl() const { return decl; }
+  bool ignoreInDebugInfo() const override { return true; }
 };
 
 /// Consider:
@@ -858,7 +870,7 @@ class AttachedPropertyWrapperScope final : public ASTScopeImpl {
   NullablePtr<DeclAttribute> getDeclAttributeIfAny() const override {
     return attr;
   }
-
+ bool ignoreInDebugInfo() const override { return true; }
 private:
   void expandAScopeThatDoesNotCreateANewInsertionPoint(ScopeCreator &);
 };
@@ -952,6 +964,7 @@ class PatternEntryInitializerScope final : public AbstractPatternEntryScope {
   std::string getClassName() const override;
   SourceRange
   getSourceRangeOfThisASTNode(bool omitAssertions = false) const override;
+  bool ignoreInDebugInfo() const override { return true; }
 
 protected:
   bool lookupLocalsOrMembers(DeclConsumer) const override;
@@ -1049,6 +1062,7 @@ class ClosureParametersScope final : public ASTScopeImpl {
   }
   NullablePtr<Expr> getExprIfAny() const override { return closureExpr; }
   Expr *getExpr() const { return closureExpr; }
+  bool ignoreInDebugInfo() const override { return true; }
 
 protected:
   ASTScopeImpl *expandSpecifically(ScopeCreator &scopeCreator) override;

include/swift/SIL/SILBuilder.h

@@ -13,6 +13,8 @@
 #ifndef SWIFT_SIL_SILBUILDER_H
 #define SWIFT_SIL_SILBUILDER_H
 
+#include "SILDebugVariable.h"
+#include "SILInstruction.h"
 #include "swift/Basic/ProfileCounter.h"
 #include "swift/SIL/SILArgument.h"
 #include "swift/SIL/SILDebugScope.h"
@@ -22,6 +24,7 @@
 #include "swift/SIL/SILUndef.h"
 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/ADT/StringExtras.h"
+#include <type_traits>
 
 namespace swift {
 
@@ -199,6 +202,7 @@ class SILBuilder {
     setCurrentDebugScope(DS);
     setInsertionPoint(BB);
   }
+  virtual ~SILBuilder() {}
 
   // Allow a pass to override the current SIL module conventions. This should
   // only be done by a pass responsible for lowering SIL to a new stage
@@ -249,7 +253,7 @@ class SILBuilder {
   }
 
   /// Convenience function for building a SILDebugLocation.
-  SILDebugLocation getSILDebugLocation(SILLocation Loc) {
+  virtual SILDebugLocation getSILDebugLocation(SILLocation Loc) {
     // FIXME: Audit all uses and enable this assertion.
     // assert(getCurrentDebugScope() && "no debug scope");
     auto Scope = getCurrentDebugScope();
@@ -259,6 +263,17 @@ class SILBuilder {
     return SILDebugLocation(overriddenLoc, Scope);
   }
 
+  /// When the frontend generates synthesized conformances it generates a
+  /// fully-typechecked AST without source locations. This means that the
+  /// ASTScope-based mechanism to generate SILDebugScopes doesn't work, which
+  /// means we can't disambiguate local variables in different lexical
+  /// scopes. To avoid a verification error later in the pipeline, drop all
+  /// variables without a proper source location.
+  bool shouldDropVariable(SILDebugVariable Var, SILLocation Loc) {
+    return !Var.ArgNo && Loc.isSynthesizedAST();
+  }
+
+
   /// If we have a SILFunction, return SILFunction::hasOwnership(). If we have a
   /// SILGlobalVariable, just return false.
   bool hasOwnership() const {
@@ -310,26 +325,38 @@ class SILBuilder {
   /// setInsertionPoint - Set the insertion point to insert before the specified
   /// instruction.
   void setInsertionPoint(SILInstruction *I) {
+#ifndef NDEBUG
+    PrevDebugScope = nullptr;
+#endif
     assert(I && "can't set insertion point to a null instruction");
     setInsertionPoint(I->getParent(), I->getIterator());
   }
 
   /// setInsertionPoint - Set the insertion point to insert before the specified
   /// instruction.
   void setInsertionPoint(SILBasicBlock::iterator IIIter) {
+#ifndef NDEBUG
+    PrevDebugScope = nullptr;
+#endif
     setInsertionPoint(IIIter->getParent(), IIIter);
   }
 
   /// setInsertionPoint - Set the insertion point to insert at the end of the
   /// specified block.
   void setInsertionPoint(SILBasicBlock *BB) {
+#ifndef NDEBUG
+    PrevDebugScope = nullptr;
+#endif
     assert(BB && "can't set insertion point to a null basic block");
     setInsertionPoint(BB, BB->end());
   }
 
   /// setInsertionPoint - Set the insertion point to insert at the end of the
   /// specified block.
   void setInsertionPoint(SILFunction::iterator BBIter) {
+#ifndef NDEBUG
+    PrevDebugScope = nullptr;
+#endif
     setInsertionPoint(&*BBIter);
   }
 
@@ -401,6 +428,8 @@ class SILBuilder {
   Optional<SILDebugVariable>
   substituteAnonymousArgs(llvm::SmallString<4> Name,
                           Optional<SILDebugVariable> Var, SILLocation Loc) {
+    if (Var && shouldDropVariable(*Var, Loc))
+      return {};
     if (!Var || !Var->ArgNo || !Var->Name.empty())
       return Var;
 
@@ -416,12 +445,19 @@ class SILBuilder {
   AllocStackInst *createAllocStack(SILLocation Loc, SILType elementType,
                                    Optional<SILDebugVariable> Var = None,
                                    bool hasDynamicLifetime = false,
-                                   bool isLexical = false,
-                                   bool wasMoved = false) {
+                                   bool isLexical = false, bool wasMoved = false
+#ifndef NDEBUG
+                                   ,
+                                   bool skipVarDeclAssert = false
+#endif
+  ) {
     llvm::SmallString<4> Name;
     Loc.markAsPrologue();
-    assert((!dyn_cast_or_null<VarDecl>(Loc.getAsASTNode<Decl>()) || Var) &&
-           "location is a VarDecl, but SILDebugVariable is empty");
+#ifndef NDEBUG
+    if (dyn_cast_or_null<VarDecl>(Loc.getAsASTNode<Decl>()))
+      assert((skipVarDeclAssert || Loc.isSynthesizedAST() || Var) &&
+             "location is a VarDecl, but SILDebugVariable is empty");
+#endif
     return insert(AllocStackInst::create(
         getSILDebugLocation(Loc), elementType, getFunction(),
         substituteAnonymousArgs(Name, Var, Loc), hasDynamicLifetime, isLexical,
@@ -474,10 +510,15 @@ class SILBuilder {
                                Optional<SILDebugVariable> Var = None,
                                bool hasDynamicLifetime = false,
                                bool reflection = false,
-                               bool usesMoveableValueDebugInfo = false) {
+                               bool usesMoveableValueDebugInfo = false
+#ifndef NDEBUG
+                               , bool skipVarDeclAssert = false
+#endif
+                               ) {
     llvm::SmallString<4> Name;
     Loc.markAsPrologue();
-    assert((!dyn_cast_or_null<VarDecl>(Loc.getAsASTNode<Decl>()) || Var) &&
+    assert((skipVarDeclAssert ||
+            !dyn_cast_or_null<VarDecl>(Loc.getAsASTNode<Decl>()) || Var) &&
            "location is a VarDecl, but SILDebugVariable is empty");
     return insert(AllocBoxInst::create(getSILDebugLocation(Loc), BoxType, *F,
                                        substituteAnonymousArgs(Name, Var, Loc),

include/swift/SIL/SILCloner.h

@@ -962,7 +962,12 @@ SILCloner<ImplClass>::visitAllocBoxInst(AllocBoxInst *Inst) {
       Inst,
       getBuilder().createAllocBox(
           Loc, this->getOpType(Inst->getType()).template castTo<SILBoxType>(),
-          VarInfo));
+          VarInfo, false, false, false
+#ifndef NDEBUG
+          ,
+          true
+#endif
+          ));
 }
 
 template<typename ImplClass>

include/swift/SIL/SILLocation.h

@@ -412,6 +412,12 @@ class SILLocation {
   /// Returns the source location for diagnoses.
   SourceLoc getSourceLoc() const;
 
+  /// Heuristic to detect the fake source locations generated for synthesized
+  /// conformances.
+  bool isSynthesizedAST() {
+    return isASTNode() && getSourceLoc().isInvalid();
+  }
+
   /// Returns the source location for debugging.
   /// See ExtendedASTNodeLoc.
   SourceLoc getSourceLocForDebugging() const;

lib/AST/ASTScopeLookup.cpp

@@ -160,7 +160,8 @@ ASTScopeImpl::findChildContaining(SourceLoc loc,
 
             auto generatedInfo =
                 sourceMgr.getGeneratedSourceInfo(*potentialLCA->getBufferID());
-            expansionLoc = generatedInfo->originalSourceRange.getStart();
+            if (generatedInfo)
+              expansionLoc = generatedInfo->originalSourceRange.getStart();
             potentialLCA = potentialLCA->getEnclosingSourceFile();
           }
         }

lib/IRGen/IRGenSIL.cpp

@@ -5745,8 +5745,6 @@ void IRGenSILFunction::visitAllocBoxInst(swift::AllocBoxInst *i) {
   if (!Decl)
     return;
 
-  assert(i->getVarInfo() && "alloc_box without debug info");
-  
   // FIXME: This is a workaround to not produce local variables for
   // capture list arguments like "[weak self]". The better solution
   // would be to require all variables to be described with a
@@ -5765,7 +5763,8 @@ void IRGenSILFunction::visitAllocBoxInst(swift::AllocBoxInst *i) {
       DebugTypeInfo::getLocalVariable(Decl, RealType, type, IGM, false);
 
   auto VarInfo = i->getVarInfo();
-  assert(VarInfo && "debug_value without debug info");
+  if (!VarInfo)
+    return;
 
   auto Storage =
       emitShadowCopyIfNeeded(boxWithAddr.getAddress(), i->getDebugScope(),

lib/SIL/IR/SILBuilder.cpp

@@ -17,6 +17,8 @@
 
 using namespace swift;
 
+extern llvm::cl::opt<bool> SILPrintDebugInfo;
+
 //===----------------------------------------------------------------------===//
 // SILBuilder Implementation
 //===----------------------------------------------------------------------===//
@@ -35,9 +37,14 @@ void SILBuilder::setCurrentDebugScope(const SILDebugScope *DS) {
     // PrevDebugScope = sil_scope(parent: CurDebugScope)
     // CurDebugScope = sil_scope(parent:)
     // DS = PrevDebugScope
-    if (DS && DS == PrevDebugScope)
+    if (DS && DS == PrevDebugScope) {
+      if (CurDebugScope->isAncestor(PrevDebugScope)) {
+        SILPrintDebugInfo.setValue(true);
+        BB->dump();
+      }
       assert(!CurDebugScope->isAncestor(PrevDebugScope) &&
              "attempting to re-enter scope within same basic block");
+    }
     PrevDebugScope = CurDebugScope;
   }
 #endif
@@ -630,6 +637,9 @@ DebugValueInst *SILBuilder::createDebugValue(SILLocation Loc, SILValue src,
                                              bool poisonRefs,
                                              bool operandWasMoved,
                                              bool trace) {
+  if (shouldDropVariable(Var, Loc))
+    return nullptr;
+
   llvm::SmallString<4> Name;
 
   // Debug location overrides cannot apply to debug value instructions.
@@ -643,6 +653,9 @@ DebugValueInst *SILBuilder::createDebugValue(SILLocation Loc, SILValue src,
 DebugValueInst *SILBuilder::createDebugValueAddr(SILLocation Loc, SILValue src,
                                                  SILDebugVariable Var,
                                                  bool wasMoved, bool trace) {
+  if (shouldDropVariable(Var, Loc))
+    return nullptr;
+
   llvm::SmallString<4> Name;
 
   // Debug location overrides cannot apply to debug addr instructions.

lib/SILGen/ResultPlan.cpp

@@ -1169,7 +1169,9 @@ ResultPlanPtr ResultPlanBuilder::buildForScalar(Initialization *init,
   if (SGF.silConv.isSILIndirect(result)) {
     auto &resultTL = SGF.getTypeLowering(result.getReturnValueType(
         SGF.SGM.M, calleeTy, SGF.getTypeExpansionContext()));
-    temporary = SGF.emitTemporary(loc, resultTL);
+    SILLocation tmpLoc(loc);
+    tmpLoc.markAutoGenerated();
+    temporary = SGF.emitTemporary(tmpLoc, resultTL);
   }
 
   return ResultPlanPtr(new ScalarResultPlan(

lib/SILGen/SILGenBuilder.cpp

@@ -46,10 +46,14 @@ SILGenBuilder::SILGenBuilder(SILGenFunction &SGF)
 
 SILGenBuilder::SILGenBuilder(SILGenFunction &SGF, SILBasicBlock *insertBB,
                              SmallVectorImpl<SILInstruction *> *insertedInsts)
-    : SILBuilder(insertBB, insertedInsts), SGF(SGF) {
+    : SILBuilder(insertBB, insertedInsts), SGF(SGF) {}
 #ifndef NDEBUG
     EnableDIHoleVerification = true;
 #endif
+
+    auto FirstInsn = insertBB->begin();
+  if (FirstInsn != insertBB->end())
+    setCurrentDebugScope(FirstInsn->getDebugScope());
 }
 
 SILGenBuilder::SILGenBuilder(SILGenFunction &SGF, SILBasicBlock *insertBB,
@@ -58,6 +62,13 @@ SILGenBuilder::SILGenBuilder(SILGenFunction &SGF, SILBasicBlock *insertBB,
 #ifndef NDEBUG
     EnableDIHoleVerification = true;
 #endif
+
+  if (insertInst != insertBB->end())
+    setCurrentDebugScope(insertInst->getDebugScope());
+}
+
+SILDebugLocation SILGenBuilder::getSILDebugLocation(SILLocation Loc) {
+  return SGF.getSILDebugLocation(*this, Loc);
 }
 
 //===----------------------------------------------------------------------===//

lib/SILGen/SILGenBuilder.h

@@ -32,6 +32,10 @@
 #include "swift/SIL/SILLocation.h"
 
 namespace swift {
+namespace ast_scope {
+class ASTScopeImpl;
+}
+
 namespace Lowering {
 
 class SILGenFunction;
@@ -50,8 +54,8 @@ class SILGenBuilder : public SILBuilder {
   SILGenBuilder(SILGenFunction &SGF, SILBasicBlock *insertBB,
                 SILBasicBlock::iterator insertInst);
 
-  // Create a new builder, inheriting the given builder's context and debug
-  // scope.
+  /// Create a new builder, inheriting the given builder's context and debug
+  /// scope.
   SILGenBuilder(SILGenBuilder &builder, SILBasicBlock *insertBB)
       : SILBuilder(insertBB, builder.getCurrentDebugScope(),
                    builder.getBuilderContext()),
@@ -64,6 +68,8 @@ class SILGenBuilder : public SILBuilder {
   SILGenModule &getSILGenModule() const;
   SILGenFunction &getSILGenFunction() const { return SGF; }
 
+  SILDebugLocation getSILDebugLocation(SILLocation Loc) override;
+
   using SILBuilder::createInitExistentialValue;
   ManagedValue
   createInitExistentialValue(SILLocation loc, SILType existentialType,