commit cbe4cca5d0c7273b571ddddd740a9a02dc1ff823
author Uday Bondhugula <bondhugula@google.com> Thu Jul 19 13:07:16 2018 -0700
committer jpienaar <jpienaar@google.com> Fri Mar 29 12:36:33 2019 -0700
tree 44786d591f932b973fbf7593539654fb816b7c56
parent 1da50c4b12244d0d68634e42d22c2cd7d9d8c060

Rename isSymbolic to isSymbolicOrConstant to avoid confusion.

PiperOrigin-RevId: 205288794

include/mlir/IR/AffineExpr.h

diff --git a/include/mlir/IR/AffineExpr.h b/include/mlir/IR/AffineExpr.h
index a19b0e1..6ebb0ae 100644
--- a/include/mlir/IR/AffineExpr.h
+++ b/include/mlir/IR/AffineExpr.h
@@ -61,7 +61,7 @@
 
   /// Returns true if this expression is made out of only symbols and
   /// constants, i.e., it does not involve dimensional identifiers.
-  bool isSymbolic() const;
+  bool isSymbolicOrConstant() const;
 
   /// Returns true if this is a pure affine expression, i.e., multiplication,
   /// floordiv, ceildiv, and mod is only allowed w.r.t constants.

lib/IR/AffineExpr.cpp

diff --git a/lib/IR/AffineExpr.cpp b/lib/IR/AffineExpr.cpp
index 54acedf..8d0ee3d 100644
--- a/lib/IR/AffineExpr.cpp
+++ b/lib/IR/AffineExpr.cpp
@@ -35,19 +35,19 @@
     break;
   case Kind::Mul:
     assert(!isa<AffineConstantExpr>(lhs));
-    assert(rhs->isSymbolic());
+    assert(rhs->isSymbolicOrConstant());
     // TODO (more verification)
     break;
   case Kind::FloorDiv:
-    assert(rhs->isSymbolic());
+    assert(rhs->isSymbolicOrConstant());
     // TODO (more verification)
     break;
   case Kind::CeilDiv:
-    assert(rhs->isSymbolic());
+    assert(rhs->isSymbolicOrConstant());
     // TODO (more verification)
     break;
   case Kind::Mod:
-    assert(rhs->isSymbolic());
+    assert(rhs->isSymbolicOrConstant());
     // TODO (more verification)
     break;
   default:
@@ -57,7 +57,7 @@
 
 /// Returns true if this expression is made out of only symbols and
 /// constants (no dimensional identifiers).
-bool AffineExpr::isSymbolic() const {
+bool AffineExpr::isSymbolicOrConstant() const {
   switch (getKind()) {
   case Kind::Constant:
     return true;
@@ -73,7 +73,8 @@
   case Kind::CeilDiv:
   case Kind::Mod: {
     auto expr = cast<AffineBinaryOpExpr>(this);
-    return expr->getLHS()->isSymbolic() && expr->getRHS()->isSymbolic();
+    return expr->getLHS()->isSymbolicOrConstant() &&
+           expr->getRHS()->isSymbolicOrConstant();
   }
   }
 }

lib/IR/AffineMap.cpp

diff --git a/lib/IR/AffineMap.cpp b/lib/IR/AffineMap.cpp
index 733c235..d8e09b5 100644
--- a/lib/IR/AffineMap.cpp
+++ b/lib/IR/AffineMap.cpp
@@ -36,7 +36,8 @@
     if (auto *r = dyn_cast<AffineConstantExpr>(rhs))
       return AffineConstantExpr::get(l->getValue() + r->getValue(), context);
 
-  if (isa<AffineConstantExpr>(lhs) || (lhs->isSymbolic() && !rhs->isSymbolic()))
+  if (isa<AffineConstantExpr>(lhs) ||
+      (lhs->isSymbolicOrConstant() && !rhs->isSymbolicOrConstant()))
     return AffineAddExpr::get(rhs, lhs, context);
 
   return nullptr;
@@ -63,12 +64,12 @@
     if (auto *r = dyn_cast<AffineConstantExpr>(rhs))
       return AffineConstantExpr::get(l->getValue() * r->getValue(), context);
 
-  assert(lhs->isSymbolic() || rhs->isSymbolic());
+  assert(lhs->isSymbolicOrConstant() || rhs->isSymbolicOrConstant());
 
   // Canonicalize the mul expression so that the constant/symbolic term is the
   // RHS. If both the lhs and rhs are symbolic, swap them if the lhs is a
   // constant. (Note that a constant is trivially symbolic).
-  if (!rhs->isSymbolic() || isa<AffineConstantExpr>(lhs)) {
+  if (!rhs->isSymbolicOrConstant() || isa<AffineConstantExpr>(lhs)) {
     // At least one of them has to be symbolic.
     return AffineMulExpr::get(rhs, lhs, context);
   }

lib/Parser/Parser.cpp

diff --git a/lib/Parser/Parser.cpp b/lib/Parser/Parser.cpp
index 71b4904..98fd716 100644
--- a/lib/Parser/Parser.cpp
+++ b/lib/Parser/Parser.cpp
@@ -717,28 +717,28 @@
   // TODO: make the error location info accurate.
   switch (op) {
   case Mul:
-    if (!lhs->isSymbolic() && !rhs->isSymbolic()) {
+    if (!lhs->isSymbolicOrConstant() && !rhs->isSymbolicOrConstant()) {
       emitError("non-affine expression: at least one of the multiply "
                 "operands has to be either a constant or symbolic");
       return nullptr;
     }
     return builder.getMulExpr(lhs, rhs);
   case FloorDiv:
-    if (!rhs->isSymbolic()) {
+    if (!rhs->isSymbolicOrConstant()) {
       emitError("non-affine expression: right operand of floordiv "
                 "has to be either a constant or symbolic");
       return nullptr;
     }
     return builder.getFloorDivExpr(lhs, rhs);
   case CeilDiv:
-    if (!rhs->isSymbolic()) {
+    if (!rhs->isSymbolicOrConstant()) {
       emitError("non-affine expression: right operand of ceildiv "
                 "has to be either a constant or symbolic");
       return nullptr;
     }
     return builder.getCeilDivExpr(lhs, rhs);
   case Mod:
-    if (!rhs->isSymbolic()) {
+    if (!rhs->isSymbolicOrConstant()) {
       emitError("non-affine expression: right operand of mod "
                 "has to be either a constant or symbolic");
       return nullptr;