Fixed a bug in StmtConditionElement::getSourceRange where it would create invalid source ranges

This bug was causing an assert.

Author: mxswd

lib/AST/Stmt.cpp

@@ -309,8 +309,13 @@ SourceRange StmtConditionElement::getSourceRange() const {
       Start = IntroducerLoc;
     else
       Start = getPattern()->getStartLoc();
-
-    return SourceRange(Start, getInitializer()->getEndLoc());
+    
+    SourceLoc End = getInitializer()->getEndLoc();
+    if (Start.isValid() && End.isValid()) {
+      return SourceRange(Start, End);
+    } else {
+      return SourceRange();
+    }
   }
 }
 
@@ -321,9 +326,18 @@ SourceLoc StmtConditionElement::getStartLoc() const {
   case StmtConditionElement::CK_Availability:
     return getAvailability()->getStartLoc();
   case StmtConditionElement::CK_PatternBinding:
+    SourceLoc Start;
     if (IntroducerLoc.isValid())
-      return IntroducerLoc;
-    return getPattern()->getStartLoc();
+      Start = IntroducerLoc;
+    else
+      Start = getPattern()->getStartLoc();
+    
+    SourceLoc End = getInitializer()->getEndLoc();
+    if (Start.isValid() && End.isValid()) {
+      return Start;
+    } else {
+      return SourceLoc();
+    }
   }
 }
 
@@ -334,7 +348,18 @@ SourceLoc StmtConditionElement::getEndLoc() const {
   case StmtConditionElement::CK_Availability:
     return getAvailability()->getEndLoc();
   case StmtConditionElement::CK_PatternBinding:
-    return getInitializer()->getEndLoc();
+    SourceLoc Start;
+    if (IntroducerLoc.isValid())
+      Start = IntroducerLoc;
+    else
+      Start = getPattern()->getStartLoc();
+  
+    SourceLoc End = getInitializer()->getEndLoc();
+    if (Start.isValid() && End.isValid()) {
+      return End;
+    } else {
+      return SourceLoc();
+    }
   }
 }
 

unittests/AST/SourceLocTests.cpp

@@ -12,6 +12,8 @@
 
 #include "TestContext.h"
 #include "swift/AST/Expr.h"
+#include "swift/AST/Pattern.h"
+#include "swift/AST/Stmt.h"
 #include "gtest/gtest.h"
 
 using namespace swift;
@@ -101,6 +103,63 @@ TEST(SourceLoc, AssignExpr) {
   EXPECT_EQ(SourceRange(), invalidAll->getSourceRange());
 }
 
+TEST(SourceLoc, StmtConditionElement) {
+  TestContext C;
+  
+  // In a pattern binding statement condition element the SourceRange is only
+  // valid iff the Initializer has a valid end loc and either:
+  // a. the IntroducerLoc has a valid start loc
+  // b. if the IntroducerLoc is invalid, the pattern has a valid start loc
+  // If neither of these hold, source range must be invalid.
+
+  auto bufferID = C.Ctx.SourceMgr //       0123456789012345678901234567890
+                        .addMemBufferCopy("if let x = Optional.some(1) { }");
+  SourceLoc start = C.Ctx.SourceMgr.getLocForBufferStart(bufferID);
+  
+  auto vardecl = new (C.Ctx) VarDecl( false, true, start.getAdvancedLoc(7)
+                                    , C.Ctx.getIdentifier("x")
+                                    , Type()
+                                    , nullptr);
+  auto pattern = new (C.Ctx) NamedPattern(vardecl);
+  auto init = new (C.Ctx) IntegerLiteralExpr( "1", start.getAdvancedLoc(25)
+                                            , false);
+  
+  // Case a, when the IntroducerLoc is valid.
+  auto introducer = StmtConditionElement( start.getAdvancedLoc(3)
+                                        , pattern, init);
+  
+  EXPECT_EQ(start.getAdvancedLoc(3), introducer.getStartLoc());
+  EXPECT_EQ(start.getAdvancedLoc(25), introducer.getEndLoc());
+  EXPECT_EQ( SourceRange(start.getAdvancedLoc(3), start.getAdvancedLoc(25))
+           , introducer.getSourceRange());
+  
+  // Case b, when the IntroducerLoc is invalid, but the pattern has a valid loc.
+  auto patternStmtCond = StmtConditionElement(SourceLoc(), pattern, init);
+  
+  EXPECT_EQ(start.getAdvancedLoc(7), patternStmtCond.getStartLoc());
+  EXPECT_EQ(start.getAdvancedLoc(25), patternStmtCond.getEndLoc());
+  EXPECT_EQ( SourceRange(start.getAdvancedLoc(7), start.getAdvancedLoc(25))
+           , patternStmtCond.getSourceRange());
+  
+  // If the IntroducerLoc is valid but the stmt cond init is invalid.
+  auto invalidInit = new (C.Ctx) IntegerLiteralExpr("1", SourceLoc(), false);
+  auto introducerStmtInvalid = StmtConditionElement( start.getAdvancedLoc(3)
+                                                   , pattern, invalidInit);
+  
+  EXPECT_EQ(SourceLoc(), introducerStmtInvalid.getStartLoc());
+  EXPECT_EQ(SourceLoc(), introducerStmtInvalid.getEndLoc());
+  EXPECT_EQ(SourceRange(), introducerStmtInvalid.getSourceRange());
+  
+  // If the IntroducerLoc is invalid, the pattern is valid, but the stmt cond 
+  // init is invalid.
+  auto patternStmtInvalid = StmtConditionElement( SourceLoc(), pattern
+                                                , invalidInit);
+  
+  EXPECT_EQ(SourceLoc(), patternStmtInvalid.getStartLoc());
+  EXPECT_EQ(SourceLoc(), patternStmtInvalid.getEndLoc());
+  EXPECT_EQ(SourceRange(), patternStmtInvalid.getSourceRange());
+}
+
 TEST(SourceLoc, TupleExpr) {
   TestContext C;