improved ast source ranges

11 files changed, 159 insertions, 154 deletions

diff --git a/include/flang/AST/Expr.h b/include/flang/AST/Expr.h
index 1ab68f1335..d7ceae4227 100644
--- a/include/flang/AST/Expr.h
+++ b/include/flang/AST/Expr.h
@@ -201,17 +201,16 @@ public:
 
 class IntegerConstantExpr : public ConstantExpr {
   APIntStorage Num;
-  IntegerConstantExpr(ASTContext &C, SourceLocation Loc,
-                      SourceLocation MaxLoc, llvm::StringRef Data);
-  IntegerConstantExpr(ASTContext &C, SourceLocation Loc,
-                      SourceLocation MaxLoc, APInt Value);
+  IntegerConstantExpr(ASTContext &C, SourceRange Range,
+                      StringRef Data);
+  IntegerConstantExpr(ASTContext &C, SourceRange Range, APInt Value);
 public:
-  static IntegerConstantExpr *Create(ASTContext &C, SourceLocation Loc,
-                                     SourceLocation MaxLoc, llvm::StringRef Data);
-  static IntegerConstantExpr *Create(ASTContext &C, SourceLocation Loc,
-                                     SourceLocation MaxLoc, APInt Value);
+  static IntegerConstantExpr *Create(ASTContext &C, SourceRange Range,
+                                     StringRef Data);
+  static IntegerConstantExpr *Create(ASTContext &C, SourceRange Range,
+                                     APInt Value);
   static IntegerConstantExpr *Create(ASTContext &C, int64_t Value) {
-    return Create(C, SourceLocation(), SourceLocation(), APInt(64, Value, true));
+    return Create(C, SourceRange(), APInt(64, Value, true));
   }
 
   APInt getValue() const { return Num.getValue(); }
@@ -225,12 +224,11 @@ public:
 class RealConstantExpr : public ConstantExpr {
 private:
   APFloatStorage Num;
-  RealConstantExpr(ASTContext &C, SourceLocation Loc,
-                   SourceLocation MaxLoc, llvm::StringRef Data,
-                   QualType Type);
+  RealConstantExpr(ASTContext &C, SourceRange Range,
+                   llvm::StringRef Data, QualType Type);
 public:
-  static RealConstantExpr *Create(ASTContext &C, SourceLocation Loc,
-                                  SourceLocation MaxLoc, llvm::StringRef Data,
+  static RealConstantExpr *Create(ASTContext &C, SourceRange Range,
+                                  llvm::StringRef Data,
                                   QualType Type);
 
   APFloat getValue() const { return Num.getValue(); }
@@ -244,11 +242,10 @@ public:
 class ComplexConstantExpr : public ConstantExpr {
 private:
   Expr *Re, *Im;
-  ComplexConstantExpr(ASTContext &C, SourceLocation Loc, SourceLocation MaxLoc,
+  ComplexConstantExpr(ASTContext &C, SourceRange Range,
                       Expr *Real, Expr *Imaginary, QualType Type);
 public:
-  static ComplexConstantExpr *Create(ASTContext &C, SourceLocation Loc,
-                                     SourceLocation MaxLoc,
+  static ComplexConstantExpr *Create(ASTContext &C, SourceRange Range,
                                      Expr *Real, Expr *Imaginary,
                                      QualType Type);
 
@@ -264,12 +261,16 @@ public:
 class CharacterConstantExpr : public ConstantExpr {
   char *Data;
 
-  CharacterConstantExpr(char *Str, SourceLocation Loc, QualType T);
-  CharacterConstantExpr(ASTContext &C, SourceLocation Loc,
-                        SourceLocation MaxLoc, llvm::StringRef Data);
+  CharacterConstantExpr(char *Str, SourceRange Range, QualType T);
+  CharacterConstantExpr(ASTContext &C, SourceRange Range,
+                        StringRef Data, QualType T);
 public:
+  static CharacterConstantExpr *Create(ASTContext &C, SourceRange Range,
+                                       StringRef Data, QualType T);
   static CharacterConstantExpr *Create(ASTContext &C, SourceLocation Loc,
-                                       SourceLocation MaxLoc, llvm::StringRef Data);
+                                       StringRef Data, QualType T) {
+    return Create(C, SourceRange(Loc, Loc), Data, T);
+  }
 
   /// CreateCopyWithCompatibleLength - if the 'this' string has the same length
   /// as the type, it returns 'this'. Otherwise it creates a new CharacterConstantExpr
@@ -312,11 +313,12 @@ public:
 
 class LogicalConstantExpr : public ConstantExpr {
   bool Val;
-  LogicalConstantExpr(ASTContext &C, SourceLocation Loc,
-                      SourceLocation MaxLoc, llvm::StringRef Data);
+
+  LogicalConstantExpr(ASTContext &C, SourceRange Range,
+                      llvm::StringRef Data, QualType T);
 public:
-  static LogicalConstantExpr *Create(ASTContext &C, SourceLocation Loc,
-                                     SourceLocation MaxLoc, llvm::StringRef Data);
+  static LogicalConstantExpr *Create(ASTContext &C, SourceRange Range,
+                                     llvm::StringRef Data, QualType T);
 
   bool isTrue() const { return Val; }
   bool isFalse() const { return !Val; }
@@ -672,11 +674,13 @@ public:
 
 /// FunctionRefExpr - a reference to a function
 class FunctionRefExpr : public Expr {
+  SourceLocation NameLocEnd;
   const FunctionDecl *Function;
-  FunctionRefExpr(SourceLocation Loc, const FunctionDecl *Func,
-                  QualType T);
+
+  FunctionRefExpr(SourceLocation Loc, SourceLocation LocEnd,
+                  const FunctionDecl *Func, QualType T);
 public:
-  static FunctionRefExpr *Create(ASTContext &C, SourceLocation Loc,
+  static FunctionRefExpr *Create(ASTContext &C, SourceRange Range,
                                  const FunctionDecl *Function);
 
   const FunctionDecl *getFunctionDecl() const { return Function; }
@@ -691,10 +695,15 @@ public:
 
 /// VarExpr -
 class VarExpr : public Expr {
+  SourceLocation NameLocEnd;
   const VarDecl *Variable;
-  VarExpr(SourceLocation Loc, const VarDecl *Var);
+
+  VarExpr(SourceLocation Loc, SourceLocation LocEnd, const VarDecl *Var);
 public:
-  static VarExpr *Create(ASTContext &C, SourceLocation L, VarDecl *V);
+  static VarExpr *Create(ASTContext &C, SourceRange Range, VarDecl *VD);
+  static VarExpr *Create(ASTContext &C, SourceLocation L, VarDecl *VD) {
+    return Create(C, SourceRange(L, L), VD);
+  }
 
   const VarDecl *getVarDecl() const { return Variable; }
 
@@ -711,11 +720,14 @@ public:
 ///
 /// Used in implied DO in the DATA statement.
 class UnresolvedIdentifierExpr : public Expr {
+  SourceLocation NameLocEnd;
   const IdentifierInfo *IDInfo;
+
   UnresolvedIdentifierExpr(ASTContext &C, SourceLocation Loc,
+                           SourceLocation LocEnd,
                            const IdentifierInfo *ID);
 public:
-  static UnresolvedIdentifierExpr *Create(ASTContext &C, SourceLocation Loc,
+  static UnresolvedIdentifierExpr *Create(ASTContext &C, SourceRange Range,
                                           const IdentifierInfo *IDInfo);
   const IdentifierInfo *getIdentifier() const { return IDInfo; }
 
diff --git a/include/flang/Parse/Parser.h b/include/flang/Parse/Parser.h
index 0c6ef6b76b..f94b8b83ef 100644
--- a/include/flang/Parse/Parser.h
+++ b/include/flang/Parse/Parser.h
@@ -215,6 +215,9 @@ private:
   /// the given location.
   SourceRange getTokenRange(SourceLocation Loc) const;
 
+  /// getTokenRange - returns the range of the current token.
+  SourceRange getTokenRange() const;
+
   //===--------------------------------------------------------------------===//
   // Low-Level token peeking and consumption methods.
   //
@@ -525,7 +528,7 @@ private:
   ExprResult ParseExpression();
   ExprResult ParseFunctionCallArgumentList(SmallVectorImpl<Expr*> &Args,
                                            SourceLocation &RParenLoc);
-  ExprResult ParseRecursiveCallExpression(SourceLocation IDLoc);
+  ExprResult ParseRecursiveCallExpression(SourceRange IDRange);
   ExprResult ParseCallExpression(SourceLocation IDLoc, FunctionDecl *Function);
   ExprResult ParseArrayConstructor();
   ExprResult ParseTypeConstructor(SourceLocation IDLoc, RecordDecl *Record);
@@ -541,7 +544,7 @@ private:
   ExprResult ParseExpectedFollowupExpression(const char *DiagAfter = "");
 
   void ParseStatementLabel();
-  ExprResult ParseStatementLabelReference(bool ConsumeToken = true);
+  ExprResult ParseStatementLabelReference(bool Consume = true);
 
   /// ParseConstructNameLabel - Parses an optional construct-name ':' label.
   /// If the construct name isn't there, then set the ConstructName to null.
diff --git a/lib/AST/Expr.cpp b/lib/AST/Expr.cpp
index 2af9d2342b..56362f1f97 100644
--- a/lib/AST/Expr.cpp
+++ b/lib/AST/Expr.cpp
@@ -37,72 +37,67 @@ SourceLocation ConstantExpr::getLocEnd() const {
   return MaxLoc;
 }
 
-IntegerConstantExpr::IntegerConstantExpr(ASTContext &C, SourceLocation Loc,
-                                         SourceLocation MaxLoc, llvm::StringRef Data)
-  : ConstantExpr(IntegerConstantExprClass, C.IntegerTy, Loc, MaxLoc) {
+IntegerConstantExpr::IntegerConstantExpr(ASTContext &C, SourceRange Range,
+                                         llvm::StringRef Data)
+  : ConstantExpr(IntegerConstantExprClass, C.IntegerTy, Range.Start, Range.End) {
   llvm::APInt Val(64,Data,10);
   Num.setValue(C, Val);
 }
 
-IntegerConstantExpr::IntegerConstantExpr(ASTContext &C, SourceLocation Loc,
-                                         SourceLocation MaxLoc, APInt Value)
-  : ConstantExpr(IntegerConstantExprClass, C.IntegerTy, Loc, MaxLoc) {
+IntegerConstantExpr::IntegerConstantExpr(ASTContext &C, SourceRange Range,
+                                         APInt Value)
+  : ConstantExpr(IntegerConstantExprClass, C.IntegerTy, Range.Start, Range.End) {
   Num.setValue(C, Value);
 }
 
-IntegerConstantExpr *IntegerConstantExpr::Create(ASTContext &C, SourceLocation Loc,
-                                                 SourceLocation MaxLoc, llvm::StringRef Data) {
-  return new (C) IntegerConstantExpr(C, Loc, MaxLoc, Data);
+IntegerConstantExpr *IntegerConstantExpr::Create(ASTContext &C, SourceRange Range,
+                                                 StringRef Data) {
+  return new (C) IntegerConstantExpr(C, Range, Data);
 }
 
-IntegerConstantExpr *IntegerConstantExpr::Create(ASTContext &C, SourceLocation Loc,
-                                                 SourceLocation MaxLoc, APInt Value) {
-  return new (C) IntegerConstantExpr(C, Loc, MaxLoc, Value);
+IntegerConstantExpr *IntegerConstantExpr::Create(ASTContext &C, SourceRange Range,
+                                                 APInt Value) {
+  return new (C) IntegerConstantExpr(C, Range, Value);
 }
 
-RealConstantExpr::RealConstantExpr(ASTContext &C, SourceLocation Loc,
-                                   SourceLocation MaxLoc, llvm::StringRef Data,
+RealConstantExpr::RealConstantExpr(ASTContext &C, SourceRange Range, llvm::StringRef Data,
                                    QualType Type)
-  : ConstantExpr(RealConstantExprClass, Type, Loc, MaxLoc) {
+  : ConstantExpr(RealConstantExprClass, Type, Range.Start, Range.End) {
   APFloat Val(C.getFPTypeSemantics(Type), Data);
   Num.setValue(C, Val);
 }
 
-RealConstantExpr *RealConstantExpr::Create(ASTContext &C, SourceLocation Loc,
-                                           SourceLocation MaxLoc, llvm::StringRef Data,
-                                           QualType Type) {
-  return new (C) RealConstantExpr(C, Loc, MaxLoc, Data, Type);
+RealConstantExpr *RealConstantExpr::Create(ASTContext &C, SourceRange Range,
+                                           llvm::StringRef Data, QualType Type) {
+  return new (C) RealConstantExpr(C, Range, Data, Type);
 }
 
-ComplexConstantExpr::ComplexConstantExpr(ASTContext &C, SourceLocation Loc, SourceLocation MaxLoc,
+ComplexConstantExpr::ComplexConstantExpr(ASTContext &C, SourceRange Range,
                                          Expr *Real, Expr *Imaginary, QualType Type)
-  : ConstantExpr(ComplexConstantExprClass, Type, Loc, MaxLoc),
+  : ConstantExpr(ComplexConstantExprClass, Type, Range.Start, Range.End),
     Re(Real), Im(Imaginary) { }
 
-ComplexConstantExpr *ComplexConstantExpr::Create(ASTContext &C, SourceLocation Loc,
-                                                 SourceLocation MaxLoc,
+ComplexConstantExpr *ComplexConstantExpr::Create(ASTContext &C, SourceRange Range,
                                                  Expr *Real, Expr *Imaginary,
                                                  QualType Type) {
-  return new (C) ComplexConstantExpr(C, Loc, MaxLoc, Real, Imaginary, Type);
+  return new (C) ComplexConstantExpr(C, Range, Real, Imaginary, Type);
 }
 
-CharacterConstantExpr::CharacterConstantExpr(ASTContext &C, SourceLocation Loc,
-                                             SourceLocation MaxLoc, llvm::StringRef data)
-  : ConstantExpr(CharacterConstantExprClass, C.CharacterTy, Loc, MaxLoc) {
-  // TODO: A 'kind' on a character literal constant.
+CharacterConstantExpr::CharacterConstantExpr(ASTContext &C, SourceRange Range,
+                                             StringRef data, QualType T)
+  : ConstantExpr(CharacterConstantExprClass, T, Range.Start, Range.End) {
   Data = new (C) char[data.size() + 1];
   std::strncpy(Data, data.data(), data.size());
   Data[data.size()] = '\0';
 }
 
-CharacterConstantExpr::CharacterConstantExpr(char *Str, SourceLocation Loc, QualType T)
-  : ConstantExpr(CharacterConstantExprClass, T, Loc, Loc), Data(Str) {
+CharacterConstantExpr::CharacterConstantExpr(char *Str, SourceRange Range, QualType T)
+  : ConstantExpr(CharacterConstantExprClass, T, Range.Start, Range.End), Data(Str) {
 }
 
-CharacterConstantExpr *CharacterConstantExpr::Create(ASTContext &C, SourceLocation Loc,
-                                                     SourceLocation MaxLoc,
-                                                     llvm::StringRef Data) {
-  return new (C) CharacterConstantExpr(C, Loc, MaxLoc, Data);
+CharacterConstantExpr *CharacterConstantExpr::Create(ASTContext &C, SourceRange Range,
+                                                     StringRef Data, QualType T) {
+  return new (C) CharacterConstantExpr(C, Range, Data, T);
 }
 
 CharacterConstantExpr *CharacterConstantExpr::
@@ -118,13 +113,13 @@ CreateCopyWithCompatibleLength(ASTContext &C, QualType T) {
     return this;
   else if(Str.size() > Len)
     // FIXME: the existing memory can be reused.
-    return Create(C, getLocation(), getLocation(), Str.slice(0, Len));
+    return Create(C, getSourceRange(), Str.slice(0, Len), T);
   else {
     auto NewData = new (C) char[Len + 1];
     std::strncpy(NewData, Str.data(), Str.size());
     std::memset(NewData + Str.size(), ' ', (Len - Str.size()));
     NewData[Len] = '\0';
-    return new (C) CharacterConstantExpr(NewData, getLocation(), T);
+    return new (C) CharacterConstantExpr(NewData, getSourceRange(), T);
   }
 }
 
@@ -160,15 +155,15 @@ BOZConstantExpr *BOZConstantExpr::Create(ASTContext &C, SourceLocation Loc,
   return new (C) BOZConstantExpr(C, Loc, MaxLoc, Data);
 }
 
-LogicalConstantExpr::LogicalConstantExpr(ASTContext &C, SourceLocation Loc,
-                                         SourceLocation MaxLoc, llvm::StringRef Data)
-  : ConstantExpr(LogicalConstantExprClass, C.LogicalTy, Loc, MaxLoc) {
+LogicalConstantExpr::LogicalConstantExpr(ASTContext &C, SourceRange Range,
+                                         llvm::StringRef Data, QualType T)
+  : ConstantExpr(LogicalConstantExprClass, T, Range.Start, Range.End) {
   Val = (Data.compare_lower(".TRUE.") == 0);
 }
 
-LogicalConstantExpr *LogicalConstantExpr::Create(ASTContext &C, SourceLocation Loc,
-                                                 SourceLocation MaxLoc, llvm::StringRef Data) {
-  return new (C) LogicalConstantExpr(C, Loc, MaxLoc, Data);
+LogicalConstantExpr *LogicalConstantExpr::Create(ASTContext &C, SourceRange Range,
+                                                 llvm::StringRef Data, QualType T) {
+  return new (C) LogicalConstantExpr(C, Range, Data, T);
 }
 
 RepeatedConstantExpr::RepeatedConstantExpr(SourceLocation Loc,
@@ -298,48 +293,48 @@ ImplicitTempArrayExpr *ImplicitTempArrayExpr::Create(ASTContext &C, Expr *E) {
   return new(C) ImplicitTempArrayExpr(E->getLocation(), E);
 }
 
-FunctionRefExpr::FunctionRefExpr(SourceLocation Loc, const FunctionDecl *Func,
-                QualType T)
-  : Expr(FunctionRefExprClass, T, Loc), Function(Func) {}
+FunctionRefExpr::FunctionRefExpr(SourceLocation Loc, SourceLocation LocEnd,
+                                 const FunctionDecl *Func, QualType T)
+  : Expr(FunctionRefExprClass, T, Loc), Function(Func), NameLocEnd(LocEnd) {}
 
-FunctionRefExpr *FunctionRefExpr::Create(ASTContext &C, SourceLocation Loc,
+FunctionRefExpr *FunctionRefExpr::Create(ASTContext &C, SourceRange Range,
                                          const FunctionDecl *Function) {
-  return new(C) FunctionRefExpr(Loc, Function, C.getFunctionType(Function));
+  return new(C) FunctionRefExpr(Range.Start, Range.End,
+                                Function, C.getFunctionType(Function));
 }
 
 SourceLocation FunctionRefExpr::getLocEnd() const {
-  return getLocation();//FIXME
+  return NameLocEnd;
 }
 
-VarExpr::VarExpr(SourceLocation Loc, const VarDecl *Var)
+VarExpr::VarExpr(SourceLocation Loc, SourceLocation LocEnd,
+                 const VarDecl *Var)
   : Expr(VarExprClass, Var->getType(), Loc),
-    Variable(Var) {}
+    Variable(Var), NameLocEnd(LocEnd) {}
 
-VarExpr *VarExpr::Create(ASTContext &C, SourceLocation Loc, VarDecl *VD) {
-  VD->MarkUsedAsVariable(Loc);
-  return new (C) VarExpr(Loc, VD);
+VarExpr *VarExpr::Create(ASTContext &C, SourceRange Range, VarDecl *VD) {
+  VD->MarkUsedAsVariable(Range.Start);
+  return new (C) VarExpr(Range.Start, Range.End, VD);
 }
 
 SourceLocation VarExpr::getLocEnd() const {
-  return SourceLocation::getFromPointer(getLocation().getPointer() +
-                               Variable->getIdentifier()->getLength());
+  return NameLocEnd;
 }
 
 UnresolvedIdentifierExpr::UnresolvedIdentifierExpr(ASTContext &C,
-                                                   SourceLocation Loc,
+                                                   SourceLocation Loc, SourceLocation LocEnd,
                                                    const IdentifierInfo *ID)
-  : Expr(UnresolvedIdentifierExprClass, C.IntegerTy, Loc), IDInfo(ID) {
-}
+  : Expr(UnresolvedIdentifierExprClass, C.IntegerTy, Loc), IDInfo(ID),
+    NameLocEnd(LocEnd) { }
 
 UnresolvedIdentifierExpr *UnresolvedIdentifierExpr::Create(ASTContext &C,
-                                                           SourceLocation Loc,
+                                                           SourceRange Range,
                                                            const IdentifierInfo *IDInfo) {
-  return new(C) UnresolvedIdentifierExpr(C, Loc, IDInfo);
+  return new(C) UnresolvedIdentifierExpr(C, Range.Start, Range.End, IDInfo);
 }
 
 SourceLocation UnresolvedIdentifierExpr::getLocEnd() const {
-  return SourceLocation::getFromPointer(getLocation().getPointer() +
-                                        IDInfo->getLength());
+  return NameLocEnd;
 }
 
 
diff --git a/lib/Parse/ParseExec.cpp b/lib/Parse/ParseExec.cpp
index eb32895a84..7ac3e1afdf 100644
--- a/lib/Parse/ParseExec.cpp
+++ b/lib/Parse/ParseExec.cpp
@@ -237,13 +237,14 @@ Parser::StmtResult Parser::ParseAssignStmt() {
     return StmtError();
 
   auto IDInfo = Tok.getIdentifierInfo();
+  auto IDRange = getTokenRange();
   auto IDLoc = Tok.getLocation();
   if(!ExpectAndConsume(tok::identifier))
     return StmtError();
   auto VD = Actions.ExpectVarRefOrDeclImplicitVar(IDLoc, IDInfo);
   if(!VD)
     return StmtError();
-  auto Var = VarExpr::Create(Context, IDLoc, VD);
+  auto Var = VarExpr::Create(Context, IDRange, VD);
 
   return Actions.ActOnAssignStmt(Context, Loc, Value, Var, StmtLabel);
 }
@@ -435,6 +436,7 @@ Parser::StmtResult Parser::ParseDoStmt() {
 
   // the do var
   auto IDInfo = Tok.getIdentifierInfo();
+  auto IDRange = getTokenRange();
   auto IDLoc = Tok.getLocation();
   if(!ExpectAndConsume(tok::identifier))
     goto error;
@@ -457,13 +459,13 @@ Parser::StmtResult Parser::ParseDoStmt() {
   }
 
   if(auto VD = Actions.ExpectVarRefOrDeclImplicitVar(IDLoc, IDInfo))
-    DoVar = VarExpr::Create(Context, IDLoc, VD);
+    DoVar = VarExpr::Create(Context, IDRange, VD);
   return Actions.ActOnDoStmt(Context, Loc, EqLoc, TerminalStmt,
                              DoVar, E1, E2, E3, StmtConstructName, StmtLabel);
 error:
   if(IDInfo) {
     if(auto VD = Actions.ExpectVarRefOrDeclImplicitVar(IDLoc, IDInfo))
-      DoVar = VarExpr::Create(Context, IDLoc, VD);
+      DoVar = VarExpr::Create(Context, IDRange, VD);
   }
   SkipUntilNextStatement();
   return Actions.ActOnDoStmt(Context, Loc, EqLoc, TerminalStmt,
@@ -755,7 +757,8 @@ FormatSpec *Parser::ParseFMTSpec(bool IsLabeled) {
     if(E.isUsable())
       return Actions.ActOnExpressionFormatSpec(Context, Loc, E.get());
     // NB: return empty format string on error.
-    return Actions.ActOnExpressionFormatSpec(Context, Loc, CharacterConstantExpr::Create(Context, Loc, Loc, ""));
+    return Actions.ActOnExpressionFormatSpec(Context, Loc,
+                                             CharacterConstantExpr::Create(Context, Loc, "", Context.CharacterTy));
   }
 
   return Actions.ActOnStarFormatSpec(Context, Loc);
diff --git a/lib/Parse/ParseExpr.cpp b/lib/Parse/ParseExpr.cpp
index dd43fcfdc0..0f43cd33c1 100644
--- a/lib/Parse/ParseExpr.cpp
+++ b/lib/Parse/ParseExpr.cpp
@@ -383,8 +383,7 @@ void Parser::SetKindSelector(ConstantExpr *E, StringRef Kind) {
   Expr *KindExpr = 0;
 
   if (::isdigit(Kind[0])) {
-    KindExpr = IntegerConstantExpr::Create(Context, Loc,
-                                           Loc,
+    KindExpr = IntegerConstantExpr::Create(Context, E->getSourceRange(),
                                            Kind);
   } else {
     std::string KindStr(Kind);
@@ -449,12 +448,10 @@ Parser::ExprResult Parser::ParsePrimaryExpr(bool IsLvalue) {
 
     StringRef Data(NumStr);
     std::pair<StringRef, StringRef> StrPair = Data.split('_');
-    E = LogicalConstantExpr::Create(Context, Loc,
-                                    getMaxLocationOfCurrentToken(),
-                                    StrPair.first);
+    E = LogicalConstantExpr::Create(Context, getTokenRange(),
+                                    StrPair.first, Context.LogicalTy);
     SetKindSelector(cast<ConstantExpr>(E.get()), StrPair.second);
-
-    Lex();
+    ConsumeToken();
     break;
   }
   case tok::binary_boz_constant:
@@ -469,17 +466,15 @@ Parser::ExprResult Parser::ParsePrimaryExpr(bool IsLvalue) {
                                 getMaxLocationOfCurrentToken(),
                                 StrPair.first);
     SetKindSelector(cast<ConstantExpr>(E.get()), StrPair.second);
-
-    Lex();
+    ConsumeToken();
     break;
   }
   case tok::char_literal_constant: {
     std::string NumStr;
     CleanLiteral(Tok, NumStr);
-    E = CharacterConstantExpr::Create(Context, Loc,
-                                      getMaxLocationOfCurrentToken(),
-                                      StringRef(NumStr));
-    Lex();
+    E = CharacterConstantExpr::Create(Context, getTokenRange(),
+                                      StringRef(NumStr), Context.CharacterTy);
+    ConsumeToken();
     // Possible substring
     if(IsPresent(tok::l_paren))
       return ParseSubstring(E);
@@ -491,8 +486,7 @@ Parser::ExprResult Parser::ParsePrimaryExpr(bool IsLvalue) {
 
     StringRef Data(NumStr);
     std::pair<StringRef, StringRef> StrPair = Data.split('_');
-    E = IntegerConstantExpr::Create(Context, Loc,
-                                    getMaxLocationOfCurrentToken(),
+    E = IntegerConstantExpr::Create(Context, getTokenRange(),
                                     StrPair.first);
     SetKindSelector(cast<ConstantExpr>(E.get()), StrPair.second);
 
@@ -505,12 +499,10 @@ Parser::ExprResult Parser::ParsePrimaryExpr(bool IsLvalue) {
 
     StringRef Data(NumStr);
     std::pair<StringRef, StringRef> StrPair = Data.split('_');
-    E = RealConstantExpr::Create(Context, Loc,
-                                 getMaxLocationOfCurrentToken(),
+    E = RealConstantExpr::Create(Context, getTokenRange(),
                                  NumStr, Context.RealTy);
     SetKindSelector(cast<ConstantExpr>(E.get()), StrPair.second);
-
-    Lex();
+    ConsumeToken();
     break;
   }
   case tok::double_precision_literal_constant: {
@@ -526,12 +518,10 @@ Parser::ExprResult Parser::ParsePrimaryExpr(bool IsLvalue) {
 
     StringRef Data(NumStr);
     std::pair<StringRef, StringRef> StrPair = Data.split('_');
-    E = RealConstantExpr::Create(Context, Loc,
-                                 getMaxLocationOfCurrentToken(),
+    E = RealConstantExpr::Create(Context, getTokenRange(),
                                  NumStr, Context.DoublePrecisionTy);
     SetKindSelector(cast<ConstantExpr>(E.get()), StrPair.second);
-
-    Lex();
+    ConsumeToken();
     break;
   }
   case tok::identifier:
@@ -621,14 +611,12 @@ ExprResult Parser::ParseDesignator(bool IsLvalue) {
 ExprResult Parser::ParseNameOrCall() {
   auto IDInfo = Tok.getIdentifierInfo();
   assert(IDInfo && "Token isn't an identifier");
+  auto IDRange = getTokenRange();
   auto IDLoc = ConsumeToken();
 
-  if(DontResolveIdentifiers) {
-    auto E = UnresolvedIdentifierExpr::Create(Context,
-                                              IDLoc,
-                                              IDInfo);
-    return E;
-  }
+  if(DontResolveIdentifiers)
+    return UnresolvedIdentifierExpr::Create(Context,
+                                            IDRange, IDInfo);
 
   // [R504]:
   //   object-name :=
@@ -653,9 +641,9 @@ ExprResult Parser::ParseNameOrCall() {
     if(IsPresent(tok::l_paren) &&
        VD->isFunctionResult() && isa<FunctionDecl>(Actions.CurContext)) {
       // FIXME: accessing function results from inner recursive functions
-      return ParseRecursiveCallExpression(IDLoc);
+      return ParseRecursiveCallExpression(IDRange);
     }
-    return VarExpr::Create(Context, IDLoc, VD);
+    return VarExpr::Create(Context, IDRange, VD);
   }
   else if(IntrinsicFunctionDecl *IFunc = dyn_cast<IntrinsicFunctionDecl>(Declaration)) {
     SmallVector<Expr*, 8> Arguments;
@@ -667,20 +655,21 @@ ExprResult Parser::ParseNameOrCall() {
   } else if(FunctionDecl *Func = dyn_cast<FunctionDecl>(Declaration)) {
     // FIXME: allow subroutines, but errors in sema
     if(!IsPresent(tok::l_paren))
-      return FunctionRefExpr::Create(Context, IDLoc, Func);
+      return FunctionRefExpr::Create(Context, IDRange, Func);
     if(!Func->isSubroutine()) {
       return ParseCallExpression(IDLoc, Func);
     }
   } else if(isa<SelfDecl>(Declaration) && isa<FunctionDecl>(Actions.CurContext))
-    return ParseRecursiveCallExpression(IDLoc);
+    return ParseRecursiveCallExpression(IDRange);
   else if(auto Record = dyn_cast<RecordDecl>(Declaration))
     return ParseTypeConstructor(IDLoc, Record);
   Diag.Report(IDLoc, diag::err_expected_var);
   return ExprError();
 }
 
-ExprResult Parser::ParseRecursiveCallExpression(SourceLocation IDLoc) {
+ExprResult Parser::ParseRecursiveCallExpression(SourceRange IDRange) {
   auto Func = Actions.CurrentContextAsFunction();
+  auto IDLoc = IDRange.Start;
   if(Func->isSubroutine()) {
     Diag.Report(IDLoc, diag::err_invalid_subroutine_use)
      << Func->getIdentifier() << getTokenRange(IDLoc);
@@ -690,7 +679,7 @@ ExprResult Parser::ParseRecursiveCallExpression(SourceLocation IDLoc) {
     return ExprError();
 
   if(!IsPresent(tok::l_paren))
-    return FunctionRefExpr::Create(Context, IDLoc, Func);
+    return FunctionRefExpr::Create(Context, IDRange, Func);
   return ParseCallExpression(IDLoc, Func);
 }
 
diff --git a/lib/Parse/ParseFormat.cpp b/lib/Parse/ParseFormat.cpp
index dd197babec..72f2c34ca7 100644
--- a/lib/Parse/ParseFormat.cpp
+++ b/lib/Parse/ParseFormat.cpp
@@ -112,8 +112,8 @@ public:
         Diag.Report(Loc, diag::err_expected_int_literal_constant);
       return nullptr;
     }
-    return IntegerConstantExpr::Create(Context, Loc,
-                                       getCurrentLoc(), Str);
+    return IntegerConstantExpr::Create(Context, SourceRange(Loc,
+                                       getCurrentLoc()), Str);
   }
 
   void MustBeDone() {
diff --git a/lib/Parse/Parser.cpp b/lib/Parse/Parser.cpp
index f5c57866b5..f78af6a444 100644
--- a/lib/Parse/Parser.cpp
+++ b/lib/Parse/Parser.cpp
@@ -110,6 +110,12 @@ SourceRange Parser::getTokenRange(SourceLocation Loc) const {
   return SourceRange(Loc, T.getLocation());
 }
 
+// FIXME:
+SourceRange Parser::getTokenRange() const {
+  return SourceRange(Tok.getLocation(), SourceLocation::getFromPointer(Tok.getLocation().getPointer() +
+                                                                       Tok.getLength()));
+}
+
 bool Parser::IsNextToken(tok::TokenKind TokKind) {
   if (NextTok.is(tok::unknown))
     TheLexer.Lex(NextTok, true);
@@ -496,24 +502,21 @@ void Parser::ParseStatementLabel() {
 
   std::string NumStr;
   CleanLiteral(Tok, NumStr);
-  StmtLabel = IntegerConstantExpr::Create(Context, Tok.getLocation(),
-                                          getMaxLocationOfCurrentToken(),
+  StmtLabel = IntegerConstantExpr::Create(Context, getTokenRange(),
                                           NumStr);
-  Lex();
+  ConsumeToken();
 }
 
 /// ParseStatementLabelReference - Parses a statement label reference token.
-ExprResult Parser::ParseStatementLabelReference(bool ConsumeToken) {
-  if(Tok.isNot(tok::int_literal_constant)) {
+ExprResult Parser::ParseStatementLabelReference(bool Consume) {
+  if(Tok.isNot(tok::int_literal_constant))
     return ExprError();
-  }
 
   std::string NumStr;
   CleanLiteral(Tok, NumStr);
-  auto Result = IntegerConstantExpr::Create(Context, Tok.getLocation(),
-                                            getMaxLocationOfCurrentToken(),
+  auto Result = IntegerConstantExpr::Create(Context, getTokenRange(),
                                             NumStr);
-  if(ConsumeToken) Lex();
+  if(Consume) ConsumeToken();
   return Result;
 }
 
diff --git a/lib/Sema/Sema.cpp b/lib/Sema/Sema.cpp
index d16e86a7e9..b9f3c32849 100644
--- a/lib/Sema/Sema.cpp
+++ b/lib/Sema/Sema.cpp
@@ -833,14 +833,14 @@ ExprResult Sema::ActOnDATAOuterImpliedDoExpr(ASTContext &C,
             // an implied do variable
             auto VD = dyn_cast<VarDecl>(Declaration);
             assert(VD);
-            return VarExpr::Create(C, Unresolved->getLocation(), VD);
+            return VarExpr::Create(C, Unresolved->getSourceRange(), VD);
           }
         } else {
            if(auto OuterDeclaration = S.ResolveIdentifier(IDInfo)) {
             if(auto VD = dyn_cast<VarDecl>(OuterDeclaration)) {
               // a constant variable
               if(VD->isParameter())
-                return VarExpr::Create(C, E->getLocation(), VD);
+                return VarExpr::Create(C, E->getSourceRange(), VD);
             }
             Diags.Report(E->getLocation(),diag::err_implied_do_expect_leaf_expr)
               << E->getSourceRange();
@@ -1039,8 +1039,7 @@ bool Sema::CheckCharacterLengthDeclarationCompability(QualType T, VarDecl *VD) {
 }
 
 QualType Sema::GetSingleDimArrayType(QualType ElTy, int Size) {
-  auto Dim = ExplicitShapeSpec::Create(Context, IntegerConstantExpr::Create(
-                                         Context, SourceLocation(), SourceLocation(), llvm::APInt(64, Size)));
+  auto Dim = ExplicitShapeSpec::Create(Context, IntegerConstantExpr::Create(Context, Size));
   return Context.getArrayType(ElTy, Dim);
 }
 
diff --git a/lib/Sema/SemaDataStmt.cpp b/lib/Sema/SemaDataStmt.cpp
index 09e9872adf..66ee448eba 100644
--- a/lib/Sema/SemaDataStmt.cpp
+++ b/lib/Sema/SemaDataStmt.cpp
@@ -308,8 +308,8 @@ ExprResult DataStmtEngine::CreateSubstringExprInitializer(SubstringExpr *E,
     Str[I] = StrVal[I - Begin];
   }
   for(; I < End; ++I) Str[I] = ' ';
-  return CharacterConstantExpr::Create(Context, Val.get()->getLocation(),
-                                       Val.get()->getLocation(), Str);
+  return CharacterConstantExpr::Create(Context, Val.get()->getSourceRange(),
+                                       Str, Context.CharacterTy);
 }
 
 void DataStmtEngine::VisitSubstringExpr(SubstringExpr *E) {
diff --git a/lib/Sema/SemaExpr.cpp b/lib/Sema/SemaExpr.cpp
index b7b6a80ea2..0c2ef67f28 100644
--- a/lib/Sema/SemaExpr.cpp
+++ b/lib/Sema/SemaExpr.cpp
@@ -337,8 +337,8 @@ ExprResult Sema::ActOnComplexConstantExpr(ASTContext &C, SourceLocation Loc,
     ImPart = ImplicitCast(C, ElementType, ImPart);
   }
 
-  return ComplexConstantExpr::Create(C, Loc,
-                                     MaxLoc, RealPart.get(), ImPart.get(),
+  return ComplexConstantExpr::Create(C, SourceRange(Loc, MaxLoc),
+                                     RealPart.get(), ImPart.get(),
                                      C.getComplexType(ElementType));
 }
 
diff --git a/lib/Sema/SemaIO.cpp b/lib/Sema/SemaIO.cpp
index f22bac63ff..a50a49d889 100644
--- a/lib/Sema/SemaIO.cpp
+++ b/lib/Sema/SemaIO.cpp
@@ -69,7 +69,8 @@ FormatSpec *Sema::ActOnExpressionFormatSpec(ASTContext &C, SourceLocation Loc,
   Diags.Report(Loc, diag::err_typecheck_expected_format_spec)
     << Type << E->getSourceRange();
   // Return an empty character literal spec when an error occurs.
-  return CharacterExpFormatSpec::Create(C, Loc, CharacterConstantExpr::Create(Context, Loc, Loc, ""));
+  return CharacterExpFormatSpec::Create(C, Loc,
+                                        CharacterConstantExpr::Create(Context, Loc, "", C.CharacterTy));
 }
 
 ExternalStarUnitSpec *Sema::ActOnStarUnitSpec(ASTContext &C, SourceLocation Loc,