Merge branch 'master' of github.com:microsoft/checkedc-clang

Author: mattmccutchen-cci

clang/include/clang/AST/Expr.h

@@ -7132,6 +7132,74 @@ class RecoveryExpr final : public Expr,
   friend class ASTStmtWriter;
 };
 
+/// \brief Represents a Checked C where clause fact.
+class WhereClauseFact {
+public:
+  enum class FactKind { BoundsDeclFact, EqualityOpFact };
+  FactKind Kind;
+
+private:
+  // For a BoundsDeclFact, Loc gives the location of the variable whose bounds
+  // are being redeclared in the where clause. For example, "_Where p :
+  // bounds(p, p + 1)".                                                     ^
+  // For an EqualityOpFact, Loc gives the location of the start of the equality
+  // expression. For example, "_Where a < 1".
+  //                                  ^
+  // TODO: Implement richer location information by capturing the start and end
+  // locations of where clause facts.
+  SourceLocation Loc;
+
+public:
+  WhereClauseFact(FactKind Kind, SourceLocation Loc)
+    : Kind(Kind), Loc(Loc) {}
+};
+
+/// \brief Represents a Checked C where clause bounds decl fact.
+class BoundsDeclFact : public WhereClauseFact {
+public:
+  VarDecl *Var;
+  BoundsExpr *Bounds;
+
+  BoundsDeclFact(VarDecl *Var, BoundsExpr *Bounds, SourceLocation Loc)
+    : WhereClauseFact(FactKind::BoundsDeclFact, Loc),
+      Var(Var), Bounds(Bounds) {}
+
+  static bool classof(const WhereClauseFact *Fact) {
+    return Fact->Kind == FactKind::BoundsDeclFact;
+  }
+};
+
+/// \brief Represents a Checked C relational operator fact.
+class EqualityOpFact : public WhereClauseFact {
+public:
+  BinaryOperator *EqualityOp;
+
+  EqualityOpFact(BinaryOperator *EqualityOp, SourceLocation Loc)
+    : WhereClauseFact(FactKind::EqualityOpFact, Loc),
+      EqualityOp(EqualityOp) {}
+
+  static bool classof(const WhereClauseFact *Fact) {
+    return Fact->Kind == FactKind::EqualityOpFact;
+  }
+};
+
+using FactListTy = llvm::SmallVector<WhereClauseFact *, 2>;
+
+/// \brief Represents a Checked C where clause.
+class WhereClause {
+private:
+  SourceLocation Loc;
+  FactListTy Facts;
+
+public:
+  WhereClause(SourceLocation Loc) : Loc(Loc) {}
+
+  void addFact(WhereClauseFact *Fact) { Facts.push_back(Fact); }
+  bool isInvalid() const { return Facts.size() == 0; }
+  FactListTy getFacts() { return Facts; }
+  static bool classof(const WhereClause *) { return true; }
+};
+
 } // end namespace clang
 
 #endif // LLVM_CLANG_AST_EXPR_H

clang/include/clang/AST/Stmt.h

@@ -59,6 +59,7 @@ class SourceManager;
 class StringLiteral;
 class Token;
 class VarDecl;
+class WhereClause;
 
 //===----------------------------------------------------------------------===//
 // AST classes for statements.
@@ -1368,15 +1369,18 @@ class DeclStmt : public Stmt {
 /// NullStmt - This is the null statement ";": C99 6.8.3p3.
 ///
 class NullStmt : public Stmt {
+private:
+  WhereClause *WClause;
 public:
   NullStmt(SourceLocation L, bool hasLeadingEmptyMacro = false)
-      : Stmt(NullStmtClass) {
+      : Stmt(NullStmtClass), WClause(nullptr) {
     NullStmtBits.HasLeadingEmptyMacro = hasLeadingEmptyMacro;
     setSemiLoc(L);
   }
 
   /// Build an empty null statement.
-  explicit NullStmt(EmptyShell Empty) : Stmt(NullStmtClass, Empty) {}
+  explicit NullStmt(EmptyShell Empty) : Stmt(NullStmtClass, Empty),
+                                        WClause(nullptr) {}
 
   SourceLocation getSemiLoc() const { return NullStmtBits.SemiLoc; }
   void setSemiLoc(SourceLocation L) { NullStmtBits.SemiLoc = L; }
@@ -1399,6 +1403,9 @@ class NullStmt : public Stmt {
   const_child_range children() const {
     return const_child_range(const_child_iterator(), const_child_iterator());
   }
+
+  void setWhereClause(WhereClause *WC) { WClause = WC; }
+  WhereClause *getWhereClause() const { return WClause; }
 };
 
   // The kind of Checked C checking to do in a scope.

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -10909,6 +10909,9 @@ def err_probability_out_of_range : Error<
    "probability argument to __builtin_expect_with_probability is outside the "
    "range [0.0, 1.0]">;
 
+def err_expected_comparison_op_in_equality_expr : Error<
+  "expected comparison operator in equality expression">;
+
 // Checked C diagnostic messages
 let CategoryName = "Checked C" in {
 

clang/include/clang/Basic/TokenKinds.def

@@ -707,6 +707,7 @@ KEYWORD(_Bounds_only               , KEYCHECKEDC)
 KEYWORD(_Exists                    , KEYCHECKEDC)
 KEYWORD(_Pack                      , KEYCHECKEDC)
 KEYWORD(_Unpack                    , KEYCHECKEDC)
+KEYWORD(_And                       , KEYCHECKEDC)
 
 // Borland Extensions which should be disabled in strict conformance mode.
 ALIAS("_pascal"      , __pascal   , KEYBORLAND)

clang/include/clang/Parse/Parser.h

@@ -2099,6 +2099,12 @@ class Parser : public CodeCompletionHandler {
   /// Parse a pack expression of the form '_Pack(expr, existential_type, substitution_type)'.
   ExprResult ParsePackExpression();
 
+  /// Parse a Checked C where clause.
+  WhereClause *ParseWhereClause();
+
+  /// Parse a Checked C where clause fact.
+  WhereClauseFact *ParseWhereClauseFact();
+
   //===--------------------------------------------------------------------===//
   // clang Expressions
 

clang/include/clang/Sema/Sema.h

@@ -4457,6 +4457,17 @@ class Sema final {
     void disable() { Active = false; }
   };
 
+  // Checked C: Perform semantic analysis on a where clause.
+  WhereClause *ActOnWhereClause(SourceLocation WhereLoc);
+
+  // Checked C: Perform semantic analysis on a where clause bounds decl fact.
+  BoundsDeclFact *ActOnBoundsDeclFact(IdentifierInfo *Id, Expr *E,
+                                      Scope *CurScope, SourceLocation IdLoc,
+                                      SourceLocation BoundsLoc);
+
+  // Checked C: Perform semantic analysis on a where clause equality-op fact.
+  EqualityOpFact *ActOnEqualityOpFact(Expr *E, SourceLocation ExprLoc);
+
   StmtResult ActOnDeclStmt(DeclGroupPtrTy Decl,
                                    SourceLocation StartLoc,
                                    SourceLocation EndLoc);

clang/lib/Parse/ParseStmt.cpp

@@ -264,6 +264,26 @@ StmtResult Parser::ParseStatementOrDeclarationAfterAttributes(
     return Actions.ActOnNullStmt(ConsumeToken(), HasLeadingEmptyMacro);
   }
 
+  // Parse Checked C _Where token.
+  case tok::kw__Where: {
+    WhereClause *WClause = ParseWhereClause();
+    if (!WClause)
+      return StmtError();
+
+    StmtResult StmtRes = Actions.ActOnNullStmt(SourceLocation());
+    if (StmtRes.isInvalid() || !isa<NullStmt>(StmtRes.get()))
+      return StmtError();
+
+    auto *NS = dyn_cast<NullStmt>(StmtRes.get());
+    NS->setWhereClause(WClause);
+
+    // The where clause should end with a semicolon.
+    if (ExpectAndConsume(tok::semi))
+      return StmtError();
+
+    return StmtRes;
+  }
+
   case tok::kw_if:                  // C99 6.8.4.1: if-statement
     return ParseIfStatement(TrailingElseLoc);
   case tok::kw_switch:              // C99 6.8.4.2: switch-statement
@@ -2588,3 +2608,65 @@ bool Parser::ParseOpenCLUnrollHintAttribute(ParsedAttributes &Attrs) {
   }
   return true;
 }
+
+WhereClauseFact *Parser::ParseWhereClauseFact() {
+  // TODO: Handle bounds expression surrounded by parentheses, like:
+  // _Where ((((p : bounds(p, p + 1))))).
+  // Equality expressions surrounded by parentheses are already handled by
+  // invoking IgnoreValuePreservingCasts in ActOnEqualityOpFact.
+
+  if (Tok.is(tok::identifier) && NextToken().is(tok::colon)) {
+    IdentifierInfo *VarName = Tok.getIdentifierInfo();
+
+    // Consume the identifier.
+    SourceLocation IdLoc = ConsumeToken();
+    // Consume the ':' token.
+    ConsumeToken();
+
+    // Get the location of the start of bounds expr.
+    SourceLocation BoundsLoc = Tok.getLocation();
+
+    // Parse a bounds decl expression.
+    ExprResult BoundsRes(ParseBoundsExpression());
+    if (BoundsRes.isInvalid())
+      return nullptr;
+    return Actions.ActOnBoundsDeclFact(VarName, BoundsRes.get(),
+                                       getCurScope(), IdLoc, BoundsLoc);
+  }
+
+  // Parse an equality expression.
+  SourceLocation ExprLoc = Tok.getLocation();
+  ExprResult ExprRes = Actions.CorrectDelayedTyposInExpr(ParseExpression());
+  if (ExprRes.isInvalid())
+    return nullptr;
+  return Actions.ActOnEqualityOpFact(ExprRes.get(), ExprLoc);
+}
+
+WhereClause *Parser::ParseWhereClause() {
+  SourceLocation WhereLoc = Tok.getLocation();
+
+  // Consume the "_Where" token.
+  if (ExpectAndConsume(tok::kw__Where)) {
+    SkipUntil(tok::semi, StopBeforeMatch);
+    return nullptr;
+  }
+
+  WhereClause *WClause = Actions.ActOnWhereClause(WhereLoc);
+  if (!WClause)
+    return nullptr;
+
+  // Parse each where clause fact. We want to issue diagnostics for as many
+  // parsing errors a possible. So we do not break on the first error.
+  bool IsError = false;
+  do {
+    WhereClauseFact *Fact = ParseWhereClauseFact();
+    if (!Fact)
+      IsError = true;
+    else
+      WClause->addFact(Fact);
+  } while (TryConsumeToken(tok::kw__And));
+
+  if (IsError)
+    return nullptr;
+  return WClause;
+}

clang/lib/Sema/SemaStmt.cpp

@@ -4504,3 +4504,68 @@ StmtResult Sema::ActOnCapturedRegionEnd(Stmt *S) {
 
   return Res;
 }
+
+WhereClause *Sema::ActOnWhereClause(SourceLocation WhereLoc) {
+  return new (Context) WhereClause(WhereLoc);
+}
+
+BoundsDeclFact
+*Sema::ActOnBoundsDeclFact(IdentifierInfo *Id, Expr *E,
+                           Scope *CurScope,
+                           SourceLocation IdLoc,
+                           SourceLocation BoundsLoc) {
+  BoundsExpr *Bounds = dyn_cast<BoundsExpr>(E);
+  if (!Bounds) {
+    Diag(BoundsLoc, diag::err_expected_bounds_expr_for_member);
+    return nullptr;
+  }
+
+  LookupResult Lookup(*this, Id, IdLoc, Sema::LookupOrdinaryName);
+  LookupParsedName(Lookup, CurScope, nullptr, true);
+  if (Lookup.empty()) {
+    Diag(IdLoc, diag::err_undeclared_var_use) << Id->getName();
+    return nullptr;
+  }
+
+  VarDecl *VD = Lookup.getAsSingle<VarDecl>();
+  if (!VD) {
+    Diag(IdLoc, diag::err_undeclared_var_use) << Id->getName();
+    return nullptr;
+  }
+
+  return new (Context) BoundsDeclFact(VD, Bounds, IdLoc);
+}
+
+EqualityOpFact *Sema::ActOnEqualityOpFact(Expr *E, SourceLocation ExprLoc) {
+  // We define an equality-op fact in terms of equality-expressions as defined
+  // in section 6.5.9 of the C11 spec. Equality-op facts have an added
+  // constraint that the equality-expressions should be non-modifying
+  // expressions.
+
+  // Here, we are checking whether E is an equality expression defined as:
+  // equality-expression:
+  //   relational-expression
+  //   equality-expression == equality-expression
+  //   equality-expression != equality-expression
+
+  Lexicographic Lex(Context, nullptr);
+  Expr *TmpE = Lex.IgnoreValuePreservingOperations(Context, E);
+
+  // TODO: Handle equality-op facts joined by logical operators, like
+  // _Where equality-op-fact && equality-op-fact || equality-op-fact.
+
+  auto *BO = dyn_cast_or_null<BinaryOperator>(TmpE);
+
+  // isComparisonOp checks for equality and relational operators.
+  if (!BO || !BO->isComparisonOp()) {
+    Diag(ExprLoc, diag::err_expected_comparison_op_in_equality_expr);
+    return nullptr;
+  }
+
+  // CheckIsNonModifying issues a diagnostic if its argument is not
+  // non-modifying.
+  if (!CheckIsNonModifying(BO->getLHS()) ||
+      !CheckIsNonModifying(BO->getRHS()))
+    return nullptr;
+  return new (Context) EqualityOpFact(BO, ExprLoc);
+}

clang/test/CheckedC/parsing/invalid-where-clause.c

@@ -0,0 +1,38 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+// Test parsing errors for incorrect where clause.
+
+int f();
+
+void invalid_cases(_Nt_array_ptr<char> p, int a, int b) {
+  _Where ; // expected-error {{expected expression}}
+  _Where ;;;;; // expected-error {{expected expression}}
+  _Where _Where; // expected-error {{expected expression}} expected-error {{expected expression}}
+  _Where _And; // expected-error {{expected expression}} expected-error {{expected expression}}
+  _Where _And _And _And; // expected-error {{expected expression}} expected-error {{expected expression}} expected-error {{expected expression}} expected-error {{expected expression}}
+  _Where a; // expected-error {{expected comparison operator in equality expression}}
+  _Where a _Where a _Where a; // expected-error {{expected comparison operator in equality expression}} expected-error {{expected comparison operator in equality expression}} expected-error {{expected comparison operator in equality expression}}
+  _Where a _And; // expected-error {{expected comparison operator in equality expression}} expected-error {{expected expression}}
+  _Where x; // expected-error {{use of undeclared identifier 'x'}}
+  _Where p : ; // expected-error {{expected bounds expression}}
+  _Where p : count(x); // expected-error {{use of undeclared identifier 'x'}}
+  _Where q : count(0); // expected-error {{use of undeclared identifier q}}
+  _Where (); // expected-error {{expected expression}}
+  _Where a = 0; // expected-error {{expected comparison operator in equality expression}}
+  _Where a == 1 _And a; // expected-error {{expected comparison operator in equality expression}}
+  _Where a _And a == 1; // expected-error {{expected comparison operator in equality expression}}
+  _Where a < 0 _And x; // expected-error {{use of undeclared identifier 'x'}}
+  _Where 1; // expected-error {{expected comparison operator in equality expression}}
+  _Where x _And p : count(0); // expected-error {{use of undeclared identifier 'x'}}
+  _Where p : count(0) _And x; // expected-error {{use of undeclared identifier 'x'}}
+  _Where a == 1 _And p : Count(0); // expected-error {{expected bounds expression}}
+  _Where p : Bounds(p, p + 1) _And a == 1; // expected-error {{expected bounds expression}}
+  where a == 1; // expected-error {{use of undeclared identifier 'where'}}
+  _Where a == 1 and a == 2; // expected-error {{expected ';'}} expected-error {{use of undeclared identifier 'and'}}
+  _Where a == 1 // expected-error {{expected ';'}}
+  _Where f(); // expected-error {{expected comparison operator in equality expression}}
+  _Where f() == 1; // expected-error {{call expression not allowed in expression}}
+  _Where 1 != f(); // expected-error {{call expression not allowed in expression}}
+  _Where a++ < 1; // expected-error {{increment expression not allowed in expression}}
+  _Where a _And p : _And q : count(0) _And x _And a = 1 _And f() < 0 _And; // expected-error {{expected comparison operator in equality expression}} expected-error {{expected bounds expression}} expected-error {{use of undeclared identifier q}} expected-error {{use of undeclared identifier 'x'}} expected-error {{expected comparison operator in equality expression}} expected-error {{call expression not allowed in expression}} expected-error {{expected expression}}
+}

clang/test/CheckedC/parsing/valid-where-clause.c

@@ -0,0 +1,32 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+// Test valid where clause cases.
+
+// expected-no-diagnostics
+
+void valid_cases(_Nt_array_ptr<char> p, _Nt_array_ptr<char> q,
+                 int a, int b) {
+  _Where a < 0;
+  _Where a > 0;
+  _Where a <= 0;
+  _Where a >= 0;
+  _Where a == 0;
+  _Where a != 0;
+  _Where 1 < 2;
+  _Where 1 == 2;
+  _Where a + b < a - b;
+  _Where a + b < 1 + 2;
+  _Where 1 + 2 > a + b;
+  _Where a + 1 == b + 2;
+  _Where a < 0 _And b > 0;
+  _Where p : bounds(p, p + 1);
+  _Where p : bounds(q, q + a);
+  _Where p : count(0);
+  _Where p : bounds(p, p + 1) _And q : bounds(q, q + 1);
+  _Where a < 0 _And p : count(0) _And b > 0 _And q : bounds(q, q + 1);
+  _Where a > 0 _And a > 1 _And a > 2 _And b < 0 _And b < 1 _And b < 2;
+  _Where p : count(a) _And p : count(a + 1) _And p : count(a + 2);
+  _Where q : count(0) _And q : bounds(q, q + 1) _And q : count(a);
+  _Where (((((a == 0)))));
+  _Where (a == 0) _And ((a == 0)) _And (((a == 0)));
+}