Rebase SILScope generation on top of ASTScope

Support for macro scopes

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 &);
 };
@@ -1049,6 +1061,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 {
 
@@ -179,27 +182,33 @@ class SILBuilder {
   /// location.
   ///
   /// SILBuilderContext must outlive this SILBuilder instance.
-  SILBuilder(SILInstruction *I, const SILDebugScope *DS, SILBuilderContext &C)
+  SILBuilder(SILInstruction *I, SILBuilderContext &C,
+             const SILDebugScope *DS = nullptr)
       : TempContext(C.getModule()), C(C), F(I->getFunction()) {
-    assert(DS && "instruction has no debug scope");
-    setCurrentDebugScope(DS);
     setInsertionPoint(I);
+    if (DS)
+      setCurrentDebugScope(DS);
   }
 
-  SILBuilder(SILBasicBlock *BB, const SILDebugScope *DS, SILBuilder &B)
-      : SILBuilder(BB, DS, B.getBuilderContext()) {}
+  SILBuilder(SILBasicBlock *BB, SILBuilder &B,
+             const SILDebugScope *DS = nullptr)
+      : SILBuilder(BB, B.getBuilderContext(), DS) {}
 
   /// Build instructions before the given insertion point, inheriting the debug
   /// location.
   ///
   /// SILBuilderContext must outlive this SILBuilder instance.
-  SILBuilder(SILBasicBlock *BB, const SILDebugScope *DS, SILBuilderContext &C)
+  SILBuilder(SILBasicBlock *BB, SILBuilderContext &C,
+             const SILDebugScope *DS = nullptr)
       : TempContext(C.getModule()), C(C), F(BB->getParent()) {
     assert(DS && "block has no debug scope");
-    setCurrentDebugScope(DS);
     setInsertionPoint(BB);
+    if (DS)
+      setCurrentDebugScope(DS);
   }
 
+  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
   // (e.g. AddressLowering).
@@ -249,7 +258,8 @@ class SILBuilder {
   }
 
   /// Convenience function for building a SILDebugLocation.
-  SILDebugLocation getSILDebugLocation(SILLocation Loc) {
+  virtual SILDebugLocation
+  getSILDebugLocation(SILLocation Loc, bool ForMetaInstruction = false) {
     // FIXME: Audit all uses and enable this assertion.
     // assert(getCurrentDebugScope() && "no debug scope");
     auto Scope = getCurrentDebugScope();
@@ -259,6 +269,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 +331,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);
   }
 
@@ -388,7 +421,7 @@ class SILBuilder {
   SILBasicBlock *createFallthroughBlock(SILLocation loc,
                                         SILBasicBlock *targetBB) {
     auto *newBB = F->createBasicBlock();
-    SILBuilder(newBB, this->getCurrentDebugScope(), this->getBuilderContext())
+    SILBuilder(newBB, this->getBuilderContext(), this->getCurrentDebugScope())
         .createBranch(loc, targetBB);
     return newBB;
   }
@@ -401,6 +434,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,14 +451,21 @@ 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(),
+        getSILDebugLocation(Loc, true), elementType, getFunction(),
         substituteAnonymousArgs(Name, Var, Loc), hasDynamicLifetime, isLexical,
         wasMoved));
   }
@@ -474,15 +516,20 @@ 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),
-                                       hasDynamicLifetime, reflection,
-                                       usesMoveableValueDebugInfo));
+    return insert(AllocBoxInst::create(
+        getSILDebugLocation(Loc, true), BoxType, *F,
+        substituteAnonymousArgs(Name, Var, Loc), hasDynamicLifetime, reflection,
+        usesMoveableValueDebugInfo));
   }
 
   AllocExistentialBoxInst *
@@ -2937,7 +2984,21 @@ class SILBuilder {
 class SILBuilderWithScope : public SILBuilder {
   void inheritScopeFrom(SILInstruction *I) {
     assert(I->getDebugScope() && "instruction has no debug scope");
-    setCurrentDebugScope(I->getDebugScope());
+    SILBasicBlock::iterator II(*I);
+    auto End = I->getParent()->end();
+    const SILDebugScope *DS = II->getDebugScope();
+    assert(DS);
+    // Skip over meta instructions, since debug_values may originate from outer
+    // scopes. Don't do any of this after inlining.
+    while (!DS->InlinedCallSite && II != End && II->isMetaInstruction())
+      ++II;
+    if (II != End) {
+      auto nextScope = II->getDebugScope();
+      if (!nextScope->InlinedCallSite)
+        DS = nextScope;
+    }
+    assert(DS);
+    setCurrentDebugScope(DS);
   }
 
 public:
@@ -2946,29 +3007,33 @@ class SILBuilderWithScope : public SILBuilder {
   ///
   /// Clients should prefer this constructor.
   SILBuilderWithScope(SILInstruction *I, SILBuilderContext &C)
-    : SILBuilder(I, I->getDebugScope(), C)
-  {}
+      : SILBuilder(I, C) {
+    inheritScopeFrom(I);
+  }
 
   /// Build instructions before the given insertion point, inheriting the debug
   /// location and using the context from the passed in builder.
   ///
   /// Clients should prefer this constructor.
   SILBuilderWithScope(SILInstruction *I, SILBuilder &B)
-      : SILBuilder(I, I->getDebugScope(), B.getBuilderContext()) {}
+      : SILBuilder(I, B.getBuilderContext()) {
+    inheritScopeFrom(I);
+  }
 
   explicit SILBuilderWithScope(
       SILInstruction *I,
       SmallVectorImpl<SILInstruction *> *InsertedInstrs = nullptr)
       : SILBuilder(I, InsertedInstrs) {
-    assert(I->getDebugScope() && "instruction has no debug scope");
-    setCurrentDebugScope(I->getDebugScope());
+    inheritScopeFrom(I);
   }
 
   explicit SILBuilderWithScope(SILBasicBlock::iterator I)
       : SILBuilderWithScope(&*I) {}
 
   explicit SILBuilderWithScope(SILBasicBlock::iterator I, SILBuilder &B)
-      : SILBuilder(&*I, &*I->getDebugScope(), B.getBuilderContext()) {}
+      : SILBuilder(&*I, B.getBuilderContext()) {
+    inheritScopeFrom(&*I);
+  }
 
   explicit SILBuilderWithScope(SILInstruction *I,
                                SILInstruction *InheritScopeFrom)
@@ -2990,12 +3055,13 @@ class SILBuilderWithScope : public SILBuilder {
 
   explicit SILBuilderWithScope(SILBasicBlock *BB, SILBuilder &B,
                                SILInstruction *InheritScopeFrom)
-      : SILBuilder(BB, InheritScopeFrom->getDebugScope(),
-                   B.getBuilderContext()) {}
+      : SILBuilder(BB, B.getBuilderContext()) {
+    inheritScopeFrom(InheritScopeFrom);
+  }
 
   explicit SILBuilderWithScope(SILBasicBlock *BB, SILBuilderContext &C,
                                const SILDebugScope *debugScope)
-      : SILBuilder(BB, debugScope, C) {}
+      : SILBuilder(BB, C, debugScope) {}
 
   /// Creates a new SILBuilder with an insertion point at the
   /// beginning of BB and the debug scope from the first

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>