[mlir][NFC] Add a using for llvm::SMLoc/llvm::SMRange to LLVM.h

[rriddle]

Summary

These are used pervasively during parsing.

Depends on D118290

mlir/docs/Tutorials/Toy/Ch-7.md

mlir::Type ToyDialect::parseType(mlir::DialectAsmParser &parser) const {
   // Parse: `struct` `<`
   if (parser.parseKeyword("struct") || parser.parseLess())
     return Type();
 
   // Parse the element types of the struct.
   SmallVector<mlir::Type, 1> elementTypes;
   do {
     // Parse the current element type.
-    llvm::SMLoc typeLoc = parser.getCurrentLocation();
+    SMLoc typeLoc = parser.getCurrentLocation();
     mlir::Type elementType;
     if (parser.parseType(elementType))
       return nullptr;
 
     // Check that the type is either a TensorType or another StructType.
     if (!elementType.isa<mlir::TensorType, StructType>()) {
       parser.emitError(typeLoc, "element type for a struct must either "
                                 "be a TensorType or a StructType, got: ")

mlir/examples/toy/Ch2/mlir/Dialect.cpp

 // Toy Operations
 //===----------------------------------------------------------------------===//
 
 /// A generalized parser for binary operations. This parses the different forms
 /// of 'printBinaryOp' below.
 static mlir::ParseResult parseBinaryOp(mlir::OpAsmParser &parser,
                                        mlir::OperationState &result) {
   SmallVector<mlir::OpAsmParser::OperandType, 2> operands;
-  llvm::SMLoc operandsLoc = parser.getCurrentLocation();
+  SMLoc operandsLoc = parser.getCurrentLocation();
   Type type;
   if (parser.parseOperandList(operands, /*requiredOperandCount=*/2) ||
       parser.parseOptionalAttrDict(result.attributes) ||
       parser.parseColonType(type))
     return mlir::failure();
 
   // If the type is a function type, it contains the input and result types of
   // this operation.

mlir/examples/toy/Ch3/mlir/Dialect.cpp

 // Toy Operations
 //===----------------------------------------------------------------------===//
 
 /// A generalized parser for binary operations. This parses the different forms
 /// of 'printBinaryOp' below.
 static mlir::ParseResult parseBinaryOp(mlir::OpAsmParser &parser,
                                        mlir::OperationState &result) {
   SmallVector<mlir::OpAsmParser::OperandType, 2> operands;
-  llvm::SMLoc operandsLoc = parser.getCurrentLocation();
+  SMLoc operandsLoc = parser.getCurrentLocation();
   Type type;
   if (parser.parseOperandList(operands, /*requiredOperandCount=*/2) ||
       parser.parseOptionalAttrDict(result.attributes) ||
       parser.parseColonType(type))
     return mlir::failure();
 
   // If the type is a function type, it contains the input and result types of
   // this operation.

mlir/examples/toy/Ch4/mlir/Dialect.cpp

 // Toy Operations
 //===----------------------------------------------------------------------===//
 
 /// A generalized parser for binary operations. This parses the different forms
 /// of 'printBinaryOp' below.
 static mlir::ParseResult parseBinaryOp(mlir::OpAsmParser &parser,
                                        mlir::OperationState &result) {
   SmallVector<mlir::OpAsmParser::OperandType, 2> operands;
-  llvm::SMLoc operandsLoc = parser.getCurrentLocation();
+  SMLoc operandsLoc = parser.getCurrentLocation();
   Type type;
   if (parser.parseOperandList(operands, /*requiredOperandCount=*/2) ||
       parser.parseOptionalAttrDict(result.attributes) ||
       parser.parseColonType(type))
     return mlir::failure();
 
   // If the type is a function type, it contains the input and result types of
   // this operation.

mlir/examples/toy/Ch5/mlir/Dialect.cpp

 // Toy Operations
 //===----------------------------------------------------------------------===//
 
 /// A generalized parser for binary operations. This parses the different forms
 /// of 'printBinaryOp' below.
 static mlir::ParseResult parseBinaryOp(mlir::OpAsmParser &parser,
                                        mlir::OperationState &result) {
   SmallVector<mlir::OpAsmParser::OperandType, 2> operands;
-  llvm::SMLoc operandsLoc = parser.getCurrentLocation();
+  SMLoc operandsLoc = parser.getCurrentLocation();
   Type type;
   if (parser.parseOperandList(operands, /*requiredOperandCount=*/2) ||
       parser.parseOptionalAttrDict(result.attributes) ||
       parser.parseColonType(type))
     return mlir::failure();
 
   // If the type is a function type, it contains the input and result types of
   // this operation.

mlir/examples/toy/Ch6/mlir/Dialect.cpp

 // Toy Operations
 //===----------------------------------------------------------------------===//
 
 /// A generalized parser for binary operations. This parses the different forms
 /// of 'printBinaryOp' below.
 static mlir::ParseResult parseBinaryOp(mlir::OpAsmParser &parser,
                                        mlir::OperationState &result) {
   SmallVector<mlir::OpAsmParser::OperandType, 2> operands;
-  llvm::SMLoc operandsLoc = parser.getCurrentLocation();
+  SMLoc operandsLoc = parser.getCurrentLocation();
   Type type;
   if (parser.parseOperandList(operands, /*requiredOperandCount=*/2) ||
       parser.parseOptionalAttrDict(result.attributes) ||
       parser.parseColonType(type))
     return mlir::failure();
 
   // If the type is a function type, it contains the input and result types of
   // this operation.

mlir/examples/toy/Ch7/mlir/Dialect.cpp

 // Toy Operations
 //===----------------------------------------------------------------------===//
 
 /// A generalized parser for binary operations. This parses the different forms
 /// of 'printBinaryOp' below.
 static mlir::ParseResult parseBinaryOp(mlir::OpAsmParser &parser,
                                        mlir::OperationState &result) {
   SmallVector<mlir::OpAsmParser::OperandType, 2> operands;
-  llvm::SMLoc operandsLoc = parser.getCurrentLocation();
+  SMLoc operandsLoc = parser.getCurrentLocation();
   Type type;
   if (parser.parseOperandList(operands, /*requiredOperandCount=*/2) ||
       parser.parseOptionalAttrDict(result.attributes) ||
       parser.parseColonType(type))
     return mlir::failure();
 
   // If the type is a function type, it contains the input and result types of
   // this operation.
mlir::Type ToyDialect::parseType(mlir::DialectAsmParser &parser) const {
   // Parse: `struct` `<`
   if (parser.parseKeyword("struct") || parser.parseLess())
     return Type();
 
   // Parse the element types of the struct.
   SmallVector<mlir::Type, 1> elementTypes;
   do {
     // Parse the current element type.
-    llvm::SMLoc typeLoc = parser.getCurrentLocation();
+    SMLoc typeLoc = parser.getCurrentLocation();
     mlir::Type elementType;
     if (parser.parseType(elementType))
       return nullptr;
 
     // Check that the type is either a TensorType or another StructType.
     if (!elementType.isa<mlir::TensorType, StructType>()) {
       parser.emitError(typeLoc, "element type for a struct must either "
                                 "be a TensorType or a StructType, got: ")

mlir/include/mlir/IR/Diagnostics.h

protected:
   raw_ostream &os;
 
   /// A functor used when determining if a location for a diagnostic should be
   /// shown. If null, all locations should be shown.
   ShouldShowLocFn shouldShowLocFn;
 
 private:
   /// Convert a location into the given memory buffer into an SMLoc.
-  llvm::SMLoc convertLocToSMLoc(FileLineColLoc loc);
+  SMLoc convertLocToSMLoc(FileLineColLoc loc);
 
   /// Given a location, returns the first nested location (including 'loc') that
   /// can be shown to the user.
   Optional<Location> findLocToShow(Location loc);
 
   /// The maximum depth that a call stack will be printed.
   /// TODO: This should be a tunable flag.
   unsigned callStackLimit = 10;

mlir/include/mlir/IR/OpImplementation.h

 class AsmParser {
 public:
   AsmParser() = default;
   virtual ~AsmParser();
 
   MLIRContext *getContext() const;
 
   /// Return the location of the original name token.
-  virtual llvm::SMLoc getNameLoc() const = 0;
+  virtual SMLoc getNameLoc() const = 0;
 
   //===--------------------------------------------------------------------===//
   // Utilities
   //===--------------------------------------------------------------------===//
 
   /// Emit a diagnostic at the specified location and return failure.
-  virtual InFlightDiagnostic emitError(llvm::SMLoc loc,
+  virtual InFlightDiagnostic emitError(SMLoc loc,
                                        const Twine &message = {}) = 0;
 
   /// Return a builder which provides useful access to MLIRContext, global
   /// objects like types and attributes.
   virtual Builder &getBuilder() const = 0;
 
   /// Get the location of the next token and store it into the argument.  This
   /// always succeeds.
-  virtual llvm::SMLoc getCurrentLocation() = 0;
-  ParseResult getCurrentLocation(llvm::SMLoc *loc) {
+  virtual SMLoc getCurrentLocation() = 0;
+  ParseResult getCurrentLocation(SMLoc *loc) {
     *loc = getCurrentLocation();
     return success();
   }
 
   /// Re-encode the given source location as an MLIR location and return it.
   /// Note: This method should only be used when a `Location` is necessary, as
   /// the encoding process is not efficient.
-  virtual Location getEncodedSourceLoc(llvm::SMLoc loc) = 0;
+  virtual Location getEncodedSourceLoc(SMLoc loc) = 0;
 
   //===--------------------------------------------------------------------===//
   // Token Parsing
   //===--------------------------------------------------------------------===//
 
   /// Parse a '->' token.
   virtual ParseResult parseArrow() = 0;
 
public:
   // Attribute/Type Parsing
   //===--------------------------------------------------------------------===//
 
   /// Invoke the `getChecked` method of the given Attribute or Type class, using
   /// the provided location to emit errors in the case of failure. Note that
   /// unlike `OpBuilder::getType`, this method does not implicitly insert a
   /// context parameter.
   template <typename T, typename... ParamsT>
-  T getChecked(llvm::SMLoc loc, ParamsT &&... params) {
+  T getChecked(SMLoc loc, ParamsT &&... params) {
     return T::getChecked([&] { return emitError(loc); },
                          std::forward<ParamsT>(params)...);
   }
   /// A variant of `getChecked` that uses the result of `getNameLoc` to emit
   /// errors.
   template <typename T, typename... ParamsT>
   T getChecked(ParamsT &&... params) {
     return T::getChecked([&] { return emitError(getNameLoc()); },
public:
   virtual ParseResult parseCustomAttributeWithFallback(
       Attribute &result, Type type,
       function_ref<ParseResult(Attribute &result, Type type)>
           parseAttribute) = 0;
 
   /// Parse an attribute of a specific kind and type.
   template <typename AttrType>
   ParseResult parseAttribute(AttrType &result, Type type = {}) {
-    llvm::SMLoc loc = getCurrentLocation();
+    SMLoc loc = getCurrentLocation();
 
     // Parse any kind of attribute.
     Attribute attr;
     if (parseAttribute(attr, type))
       return failure();
 
     // Check for the right kind of attribute.
     if (!(result = attr.dyn_cast<AttrType>()))
public:
   }
 
   /// Parse an arbitrary attribute of a given type and populate it in `result`.
   /// This also adds the attribute to the specified attribute list with the
   /// specified name.
   template <typename AttrType>
   ParseResult parseAttribute(AttrType &result, Type type, StringRef attrName,
                              NamedAttrList &attrs) {
-    llvm::SMLoc loc = getCurrentLocation();
+    SMLoc loc = getCurrentLocation();
 
     // Parse any kind of attribute.
     Attribute attr;
     if (parseAttribute(attr, type))
       return failure();
 
     // Check for the right kind of attribute.
     result = attr.dyn_cast<AttrType>();
public:
   /// Parse a custom attribute of a given type unless the next token is `#`, in
   /// which case the generic parser is invoked. The parsed attribute is
   /// populated in `result` and also added to the specified attribute list with
   /// the specified name.
   template <typename AttrType>
   std::enable_if_t<detect_has_parse_method<AttrType>::value, ParseResult>
   parseCustomAttributeWithFallback(AttrType &result, Type type,
                                    StringRef attrName, NamedAttrList &attrs) {
-    llvm::SMLoc loc = getCurrentLocation();
+    SMLoc loc = getCurrentLocation();
 
     // Parse any kind of attribute.
     Attribute attr;
     if (parseCustomAttributeWithFallback(
             attr, type, [&](Attribute &result, Type type) -> ParseResult {
               result = AttrType::parse(*this, type);
               if (!result)
                 return failure();
public:
   }
 
   /// Parse a custom attribute of a given type unless the next token is `#`, in
   /// which case the generic parser is invoked. The parsed attribute is
   /// populated in `result`.
   template <typename AttrType>
   std::enable_if_t<detect_has_parse_method<AttrType>::value, ParseResult>
   parseCustomAttributeWithFallback(AttrType &result) {
-    llvm::SMLoc loc = getCurrentLocation();
+    SMLoc loc = getCurrentLocation();
 
     // Parse any kind of attribute.
     Attribute attr;
     if (parseCustomAttributeWithFallback(
             attr, {}, [&](Attribute &result, Type type) -> ParseResult {
               result = AttrType::parse(*this, type);
               return success(!!result);
             }))
virtual ParseResult parseCustomTypeWithFallback(
       Type &result, function_ref<ParseResult(Type &result)> parseType) = 0;
 
   /// Parse an optional type.
   virtual OptionalParseResult parseOptionalType(Type &result) = 0;
 
   /// Parse a type of a specific type.
   template <typename TypeT>
   ParseResult parseType(TypeT &result) {
-    llvm::SMLoc loc = getCurrentLocation();
+    SMLoc loc = getCurrentLocation();
 
     // Parse any kind of type.
     Type type;
     if (parseType(type))
       return failure();
 
     // Check for the right kind of type.
     result = type.dyn_cast<TypeT>();
using detect_type_has_parse_method =
       llvm::is_detected<type_has_parse_method, TypeT>;
 
   /// Parse a custom Type of a given type unless the next token is `#`, in
   /// which case the generic parser is invoked. The parsed Type is
   /// populated in `result`.
   template <typename TypeT>
   std::enable_if_t<detect_type_has_parse_method<TypeT>::value, ParseResult>
   parseCustomTypeWithFallback(TypeT &result) {
-    llvm::SMLoc loc = getCurrentLocation();
+    SMLoc loc = getCurrentLocation();
 
     // Parse any kind of Type.
     Type type;
     if (parseCustomTypeWithFallback(type, [&](Type &result) -> ParseResult {
           result = TypeT::parse(*this);
           return success(!!result);
         }))
       return failure();
public:
   parseOptionalArrowTypeList(SmallVectorImpl<Type> &result) = 0;
 
   /// Parse a colon followed by a type.
   virtual ParseResult parseColonType(Type &result) = 0;
 
   /// Parse a colon followed by a type of a specific kind, e.g. a FunctionType.
   template <typename TypeType>
   ParseResult parseColonType(TypeType &result) {
-    llvm::SMLoc loc = getCurrentLocation();
+    SMLoc loc = getCurrentLocation();
 
     // Parse any kind of type.
     Type type;
     if (parseColonType(type))
       return failure();
 
     // Check for the right kind of type.
     result = type.dyn_cast<TypeType>();
public:
   virtual FailureOr<OperationName> parseCustomOperationName() = 0;
 
   //===--------------------------------------------------------------------===//
   // Operand Parsing
   //===--------------------------------------------------------------------===//
 
   /// This is the representation of an operand reference.
   struct OperandType {
-    llvm::SMLoc location; // Location of the token.
+    SMLoc location; // Location of the token.
     StringRef name;       // Value name, e.g. %42 or %abc
     unsigned number;      // Number, e.g. 12 for an operand like %xyz#12
   };
 
   /// Parse different components, viz., use-info of operand(s), successor(s),
   /// region(s), attribute(s) and function-type, of the generic form of an
   /// operation instance and populate the input operation-state 'result' with
   /// those components. If any of the components is explicitly provided, then
for (auto elt : operands)
         return failure();
     return success();
   }
 
   /// Resolve a list of operands and a list of operand types to SSA values,
   /// emitting an error and returning failure, or appending the results
   /// to the list on success.
   ParseResult resolveOperands(ArrayRef<OperandType> operands,
-                              ArrayRef<Type> types, llvm::SMLoc loc,
+                              ArrayRef<Type> types, SMLoc loc,
                               SmallVectorImpl<Value> &result) {
     if (operands.size() != types.size())
       return emitError(loc)
              << operands.size() << " operands present, but expected "
              << types.size();
 
     for (unsigned i = 0, e = operands.size(); i != e; ++i)
       if (resolveOperand(operands[i], types[i], result))
         return failure();
     return success();
   }
   template <typename Operands>
-  ParseResult resolveOperands(Operands &&operands, Type type, llvm::SMLoc loc,
+  ParseResult resolveOperands(Operands &&operands, Type type, SMLoc loc,
                               SmallVectorImpl<Value> &result) {
     return resolveOperands(std::forward<Operands>(operands),
                            ArrayRef<Type>(type), loc, result);
   }
   template <typename Operands, typename Types>
   std::enable_if_t<!std::is_convertible<Types, Type>::value, ParseResult>
-  resolveOperands(Operands &&operands, Types &&types, llvm::SMLoc loc,
+  resolveOperands(Operands &&operands, Types &&types, SMLoc loc,
                   SmallVectorImpl<Value> &result) {
     size_t operandSize = std::distance(operands.begin(), operands.end());
     size_t typeSize = std::distance(types.begin(), types.end());
     if (operandSize != typeSize)
       return emitError(loc)
              << operandSize << " operands present, but expected " << typeSize;
 
     for (auto it : llvm::zip(operands, types))

mlir/include/mlir/Parser/AsmParserState.h

 class AsmParserState {
 public:
   /// This class represents a definition within the source manager, containing
   /// it's defining location and locations of any uses. SMDefinitions are only
   /// provided for entities that have uses within an input file, e.g. SSA
   /// values, Blocks, and Symbols.
   struct SMDefinition {
     SMDefinition() = default;
-    SMDefinition(llvm::SMRange loc) : loc(loc) {}
+    SMDefinition(SMRange loc) : loc(loc) {}
 
     /// The source location of the definition.
-    llvm::SMRange loc;
+    SMRange loc;
     /// The source location of all uses of the definition.
-    SmallVector<llvm::SMRange> uses;
+    SmallVector<SMRange> uses;
   };
 
   /// This class represents the information for an operation definition within
   /// an input file.
   struct OperationDefinition {
     struct ResultGroupDefinition {
-      ResultGroupDefinition(unsigned index, llvm::SMRange loc)
+      ResultGroupDefinition(unsigned index, SMRange loc)
           : startIndex(index), definition(loc) {}
 
       /// The result number that starts this group.
       unsigned startIndex;
       /// The source definition of the result group.
       SMDefinition definition;
     };
 
-    OperationDefinition(Operation *op, llvm::SMRange loc, llvm::SMLoc endLoc)
+    OperationDefinition(Operation *op, SMRange loc, SMLoc endLoc)
         : op(op), loc(loc), scopeLoc(loc.Start, endLoc) {}
 
     /// The operation representing this definition.
     Operation *op;
 
     /// The source location for the operation, i.e. the location of its name.
-    llvm::SMRange loc;
+    SMRange loc;
 
     /// The full source range of the operation definition, i.e. a range
     /// encompassing the start and end of the full operation definition.
-    llvm::SMRange scopeLoc;
+    SMRange scopeLoc;
 
     /// Source definitions for any result groups of this operation.
     SmallVector<ResultGroupDefinition> resultGroups;
 
     /// If this operation is a symbol operation, this vector contains symbol
     /// uses of this operation.
-    SmallVector<llvm::SMRange> symbolUses;
+    SmallVector<SMRange> symbolUses;
   };
 
   /// This class represents the information for a block definition within the
   /// input file.
   struct BlockDefinition {
-    BlockDefinition(Block *block, llvm::SMRange loc = {})
+    BlockDefinition(Block *block, SMRange loc = {})
         : block(block), definition(loc) {}
 
     /// The block representing this definition.
     Block *block;
 
     /// The source location for the block, i.e. the location of its name, and
     /// any uses it has.
     SMDefinition definition;
public:
   iterator_range<OperationDefIterator> getOpDefs() const;
 
   /// Return the definition for the given operation, or nullptr if the given
   /// operation does not have a definition.
   const OperationDefinition *getOpDef(Operation *op) const;
 
   /// Returns (heuristically) the range of an identifier given a SMLoc
   /// corresponding to the start of an identifier location.
-  static llvm::SMRange convertIdLocToRange(llvm::SMLoc loc);
+  static SMRange convertIdLocToRange(SMLoc loc);
 
   //===--------------------------------------------------------------------===//
   // Populate State
   //===--------------------------------------------------------------------===//
 
   /// Initialize the state in preparation for populating more parser state under
   /// the given top-level operation.
   void initialize(Operation *topLevelOp);
 
   /// Finalize any in-progress parser state under the given top-level operation.
   void finalize(Operation *topLevelOp);
 
   /// Start a definition for an operation with the given name.
   void startOperationDefinition(const OperationName &opName);
 
   /// Finalize the most recently started operation definition.
   void finalizeOperationDefinition(
-      Operation *op, llvm::SMRange nameLoc, llvm::SMLoc endLoc,
-      ArrayRef<std::pair<unsigned, llvm::SMLoc>> resultGroups = llvm::None);
+      Operation *op, SMRange nameLoc, SMLoc endLoc,
+      ArrayRef<std::pair<unsigned, SMLoc>> resultGroups = llvm::None);
 
   /// Start a definition for a region nested under the current operation.
   void startRegionDefinition();
 
   /// Finalize the most recently started region definition.
   void finalizeRegionDefinition();
 
   /// Add a definition of the given entity.
-  void addDefinition(Block *block, llvm::SMLoc location);
-  void addDefinition(BlockArgument blockArg, llvm::SMLoc location);
+  void addDefinition(Block *block, SMLoc location);
+  void addDefinition(BlockArgument blockArg, SMLoc location);
 
   /// Add a source uses of the given value.
-  void addUses(Value value, ArrayRef<llvm::SMLoc> locations);
-  void addUses(Block *block, ArrayRef<llvm::SMLoc> locations);
+  void addUses(Value value, ArrayRef<SMLoc> locations);
+  void addUses(Block *block, ArrayRef<SMLoc> locations);
 
   /// Add source uses for all the references nested under `refAttr`. The
   /// provided `locations` should match 1-1 with the number of references in
   /// `refAttr`, i.e.:
   ///   nestedReferences.size() + /*leafReference=*/1 == refLocations.size()
-  void addUses(SymbolRefAttr refAttr, ArrayRef<llvm::SMRange> refLocations);
+  void addUses(SymbolRefAttr refAttr, ArrayRef<SMRange> refLocations);
 
   /// Refine the `oldValue` to the `newValue`. This is used to indicate that
   /// `oldValue` was a placeholder, and the uses of it should really refer to
   /// `newValue`.
   void refineDefinition(Value oldValue, Value newValue);
 
 private:
   struct Impl;
 
   /// A pointer to the internal implementation of this class.
   std::unique_ptr<Impl> impl;
 };
 
 } // namespace mlir
 
 #endif // MLIR_PARSER_ASMPARSERSTATE_H

mlir/include/mlir/Support/LLVM.h

 
 // Other common classes.
 class APInt;
 class APSInt;
 class APFloat;
 template <typename Fn> class function_ref;
 template <typename IteratorT> class iterator_range;
 class raw_ostream;
+class SMLoc;
+class SMRange;
 } // namespace llvm
 
 namespace mlir {
 // Casting operators.
 using llvm::cast;
 using llvm::cast_or_null;
 using llvm::dyn_cast;
 using llvm::dyn_cast_or_null;

 
 // Other common classes.
 using llvm::APFloat;
 using llvm::APInt;
 using llvm::APSInt;
 template <typename Fn> using function_ref = llvm::function_ref<Fn>;
 using llvm::iterator_range;
 using llvm::raw_ostream;
+using llvm::SMLoc;
+using llvm::SMRange;
 } // namespace mlir
 
 #endif // MLIR_SUPPORT_LLVM_H

mlir/include/mlir/TableGen/AttrOrTypeDef.h

public:
   // Return true if we need to generate the verify declaration and getChecked
   // method.
   bool genVerifyDecl() const;
 
   // Returns the def's extra class declaration code.
   Optional<StringRef> getExtraDecls() const;
 
   // Get the code location (for error printing).
-  ArrayRef<llvm::SMLoc> getLoc() const;
+  ArrayRef<SMLoc> getLoc() const;
 
   // Returns true if the default get/getChecked methods should be skipped during
   // generation.
   bool skipDefaultBuilders() const;
 
   // Returns the builders of this def.
   ArrayRef<AttrOrTypeBuilder> getBuilders() const { return builders; }
 

mlir/include/mlir/TableGen/Builder.h

private:
     /// or a CArg DefInit.
     const llvm::Init *def;
 
     // Allow access to the constructor.
     friend Builder;
   };
 
   /// Construct a builder from the given Record instance.
-  Builder(const llvm::Record *record, ArrayRef<llvm::SMLoc> loc);
+  Builder(const llvm::Record *record, ArrayRef<SMLoc> loc);
 
   /// Return a list of parameters used in this build method.
   ArrayRef<Parameter> getParameters() const { return parameters; }
 
   /// Return an optional string containing the body of the builder.
   Optional<StringRef> getBody() const;
 
 protected:

mlir/include/mlir/TableGen/Operator.h

public:
   unsigned getNumVariadicSuccessors() const;
 
   // Trait.
   using const_trait_iterator = const Trait *;
   const_trait_iterator trait_begin() const;
   const_trait_iterator trait_end() const;
   llvm::iterator_range<const_trait_iterator> getTraits() const;
 
-  ArrayRef<llvm::SMLoc> getLoc() const;
+  ArrayRef<SMLoc> getLoc() const;
 
   // Query functions for the documentation of the operator.
   bool hasDescription() const;
   StringRef getDescription() const;
   bool hasSummary() const;
   StringRef getSummary() const;
 
   // Query functions for the assembly format of the operator.

mlir/include/mlir/TableGen/Pattern.h

 // only the N-th *static* result as declared in ODS, and that can still
 // corresponds to multiple *dynamic* values if the N-th *static* result is
 // variadic.
 //
 // This class keeps track of such symbols and resolves them into their bound
 // values in a suitable way.
 class SymbolInfoMap {
 public:
-  explicit SymbolInfoMap(ArrayRef<llvm::SMLoc> loc) : loc(loc) {}
+  explicit SymbolInfoMap(ArrayRef<SMLoc> loc) : loc(loc) {}
 
   // Class for information regarding a symbol.
   class SymbolInfo {
   public:
     // Returns a type string of a variable.
     std::string getVarTypeStr(StringRef name) const;
 
     // Returns a string for defining a variable named as `name` to store the
public:
   // `name`. `name` is typically the results of an multi-result op.
   static StringRef getValuePackName(StringRef symbol, int *index = nullptr);
 
 private:
   BaseT symbolInfoMap;
 
   // Pattern instantiation location. This is intended to be used as parameter
   // to PrintFatalError() to report errors.
-  ArrayRef<llvm::SMLoc> loc;
+  ArrayRef<SMLoc> loc;
 };
 
 // Wrapper class providing helper methods for accessing MLIR Pattern defined
 // in TableGen. This class should closely reflect what is defined as class
 // `Pattern` in TableGen. This class contains maps so it is not intended to be
 // used as values.
 class Pattern {
 public:

mlir/include/mlir/TableGen/Predicate.h

public:
   // the underlying predicate type.
   std::string getCondition() const;
 
   // Whether the predicate is a combination of other predicates, i.e. an
   // record of type CombinedPred.
   bool isCombined() const;
 
   // Get the location of the predicate.
-  ArrayRef<llvm::SMLoc> getLoc() const;
+  ArrayRef<SMLoc> getLoc() const;
 
   // Records are pointer-comparable.
   bool operator==(const Pred &other) const { return def == other.def; }
 
   // Return true if the predicate is not null.
   operator bool() const { return def; }
 
   // Hash a predicate by its pointer value.

mlir/include/mlir/Tools/PDLL/AST/Diagnostic.h

public:
 
   /// Return the severity of this diagnostic.
   Severity getSeverity() const { return severity; }
 
   /// Return the message of this diagnostic.
   StringRef getMessage() const { return message; }
 
   /// Return the location of this diagnostic.
-  llvm::SMRange getLocation() const { return location; }
+  SMRange getLocation() const { return location; }
 
   /// Return the notes of this diagnostic.
   auto getNotes() const { return llvm::make_pointee_range(notes); }
 
   /// Attach a note to this diagnostic.
   Diagnostic &attachNote(const Twine &msg,
-                         Optional<llvm::SMRange> noteLoc = llvm::None) {
+                         Optional<SMRange> noteLoc = llvm::None) {
     assert(getSeverity() != Severity::DK_Note &&
            "cannot attach a Note to a Note");
     notes.emplace_back(
         new Diagnostic(Severity::DK_Note, noteLoc.getValueOr(location), msg));
     return *notes.back();
   }
 
   /// Allow an inflight diagnostic to be converted to 'failure', otherwise
   /// 'success' if this is an empty diagnostic.
   operator LogicalResult() const { return failure(); }
 
 private:
-  Diagnostic(Severity severity, llvm::SMRange loc, const Twine &msg)
+  Diagnostic(Severity severity, SMRange loc, const Twine &msg)
       : severity(severity), message(msg.str()), location(loc) {}
 
   // Allow access to the constructor.
   friend DiagnosticEngine;
 
   /// The severity of this diagnostic.
   Severity severity;
   /// The message held by this diagnostic.
   std::string message;
   /// The raw location of this diagnostic.
-  llvm::SMRange location;
+  SMRange location;
   /// Any additional note diagnostics attached to this diagnostic.
   std::vector<std::unique_ptr<Diagnostic>> notes;
 };
 
 //===----------------------------------------------------------------------===//
 // InFlightDiagnostic
 //===----------------------------------------------------------------------===//
 

 
 /// This class manages the construction and emission of PDLL diagnostics.
 class DiagnosticEngine {
 public:
   /// A function used to handle diagnostics emitted by the engine.
   using HandlerFn = llvm::unique_function<void(Diagnostic &)>;
 
   /// Emit an error to the diagnostic engine.
-  InFlightDiagnostic emitError(llvm::SMRange loc, const Twine &msg) {
+  InFlightDiagnostic emitError(SMRange loc, const Twine &msg) {
     return InFlightDiagnostic(
         this, Diagnostic(Diagnostic::Severity::DK_Error, loc, msg));
   }
-  InFlightDiagnostic emitWarning(llvm::SMRange loc, const Twine &msg) {
+  InFlightDiagnostic emitWarning(SMRange loc, const Twine &msg) {
     return InFlightDiagnostic(
         this, Diagnostic(Diagnostic::Severity::DK_Warning, loc, msg));
   }
 
   /// Report the given diagnostic.
   void report(Diagnostic &&diagnostic) {
     if (handler)
       handler(diagnostic);

mlir/include/mlir/Tools/PDLL/AST/Nodes.h

 
 //===----------------------------------------------------------------------===//
 // Name
 //===----------------------------------------------------------------------===//
 
 /// This class provides a convenient API for interacting with source names. It
 /// contains a string name as well as the source location for that name.
 struct Name {
   static const Name &create(Context &ctx, StringRef name,
-                            llvm::SMRange location);
+                            SMRange location);
 
   /// Return the raw string name.
   StringRef getName() const { return name; }
 
   /// Get the location of this name.
-  llvm::SMRange getLoc() const { return location; }
+  SMRange getLoc() const { return location; }
 
 private:
   Name() = delete;
   Name(const Name &) = delete;
   Name &operator=(const Name &) = delete;
-  Name(StringRef name, llvm::SMRange location)
+  Name(StringRef name, SMRange location)
       : name(name), location(location) {}
 
   /// The string name of the decl.
   StringRef name;
   /// The location of the decl name.
-  llvm::SMRange location;
+  SMRange location;
 };
 
 //===----------------------------------------------------------------------===//
 // DeclScope
 //===----------------------------------------------------------------------===//
 
 /// This class represents a scope for named AST decls. A scope determines the
 /// visibility and lifetime of a named declaration.
public:
 
     /// Provide type casting support.
     static bool classof(const Node *node) {
       return node->getTypeID() == TypeID::get<T>();
     }
 
   protected:
     template <typename... Args>
-    explicit NodeBase(llvm::SMRange loc, Args &&...args)
+    explicit NodeBase(SMRange loc, Args &&...args)
         : BaseT(TypeID::get<T>(), loc, std::forward<Args>(args)...) {}
   };
 
   /// Return the type identifier of this node.
   TypeID getTypeID() const { return typeID; }
 
   /// Return the location of this node.
-  llvm::SMRange getLoc() const { return loc; }
+  SMRange getLoc() const { return loc; }
 
   /// Print this node to the given stream.
   void print(raw_ostream &os) const;
 
 protected:
-  Node(TypeID typeID, llvm::SMRange loc) : typeID(typeID), loc(loc) {}
+  Node(TypeID typeID, SMRange loc) : typeID(typeID), loc(loc) {}
 
 private:
   /// A unique type identifier for this node.
   TypeID typeID;
 
   /// The location of this node.
-  llvm::SMRange loc;
+  SMRange loc;
 };
 
 //===----------------------------------------------------------------------===//
 // Stmt
 //===----------------------------------------------------------------------===//
 
 /// This class represents a base AST Statement node.
 class Stmt : public Node {
 public:
   using Node::Node;
 
   /// Provide type casting support.
   static bool classof(const Node *node);
 };
 
 //===----------------------------------------------------------------------===//
 // CompoundStmt
 //===----------------------------------------------------------------------===//
 
 /// This statement represents a compound statement, which contains a collection
 /// of other statements.
 class CompoundStmt final : public Node::NodeBase<CompoundStmt, Stmt>,
                            private llvm::TrailingObjects<CompoundStmt, Stmt *> {
 public:
-  static CompoundStmt *create(Context &ctx, llvm::SMRange location,
+  static CompoundStmt *create(Context &ctx, SMRange location,
                               ArrayRef<Stmt *> children);
 
   /// Return the children of this compound statement.
   MutableArrayRef<Stmt *> getChildren() {
     return {getTrailingObjects<Stmt *>(), numChildren};
   }
   ArrayRef<Stmt *> getChildren() const {
     return const_cast<CompoundStmt *>(this)->getChildren();
   }
   ArrayRef<Stmt *>::iterator begin() const { return getChildren().begin(); }
   ArrayRef<Stmt *>::iterator end() const { return getChildren().end(); }
 
 private:
-  CompoundStmt(llvm::SMRange location, unsigned numChildren)
+  CompoundStmt(SMRange location, unsigned numChildren)
       : Base(location), numChildren(numChildren) {}
 
   /// The number of held children statements.
   unsigned numChildren;
 
   // Allow access to various privates.
   friend class llvm::TrailingObjects<CompoundStmt, Stmt *>;
 };
 
 //===----------------------------------------------------------------------===//
 // LetStmt
 //===----------------------------------------------------------------------===//
 
 /// This statement represents a `let` statement in PDLL. This statement is used
 /// to define variables.
 class LetStmt final : public Node::NodeBase<LetStmt, Stmt> {
 public:
-  static LetStmt *create(Context &ctx, llvm::SMRange loc,
+  static LetStmt *create(Context &ctx, SMRange loc,
                          VariableDecl *varDecl);
 
   /// Return the variable defined by this statement.
   VariableDecl *getVarDecl() const { return varDecl; }
 
 private:
-  LetStmt(llvm::SMRange loc, VariableDecl *varDecl)
+  LetStmt(SMRange loc, VariableDecl *varDecl)
       : Base(loc), varDecl(varDecl) {}
 
   /// The variable defined by this statement.
   VariableDecl *varDecl;
 };
 
 //===----------------------------------------------------------------------===//
 // OpRewriteStmt
 //===----------------------------------------------------------------------===//
 
 /// This class represents a base operation rewrite statement. Operation rewrite
 /// statements perform a set of transformations on a given root operation.
 class OpRewriteStmt : public Stmt {
 public:
   /// Provide type casting support.
   static bool classof(const Node *node);
 
   /// Return the root operation of this rewrite.
   Expr *getRootOpExpr() const { return rootOp; }
 
 protected:
-  OpRewriteStmt(TypeID typeID, llvm::SMRange loc, Expr *rootOp)
+  OpRewriteStmt(TypeID typeID, SMRange loc, Expr *rootOp)
       : Stmt(typeID, loc), rootOp(rootOp) {}
 
 protected:
   /// The root operation being rewritten.
   Expr *rootOp;
 };
 
 //===----------------------------------------------------------------------===//
 // EraseStmt
 
 /// This statement represents the `erase` statement in PDLL. This statement
 /// erases the given root operation, corresponding roughly to the
 /// PatternRewriter::eraseOp API.
 class EraseStmt final : public Node::NodeBase<EraseStmt, OpRewriteStmt> {
 public:
-  static EraseStmt *create(Context &ctx, llvm::SMRange loc, Expr *rootOp);
+  static EraseStmt *create(Context &ctx, SMRange loc, Expr *rootOp);
 
 private:
-  EraseStmt(llvm::SMRange loc, Expr *rootOp) : Base(loc, rootOp) {}
+  EraseStmt(SMRange loc, Expr *rootOp) : Base(loc, rootOp) {}
 };
 
 //===----------------------------------------------------------------------===//
 // ReplaceStmt
 
 /// This statement represents the `replace` statement in PDLL. This statement
 /// replace the given root operation with a set of values, corresponding roughly
 /// to the PatternRewriter::replaceOp API.
 class ReplaceStmt final : public Node::NodeBase<ReplaceStmt, OpRewriteStmt>,
                           private llvm::TrailingObjects<ReplaceStmt, Expr *> {
 public:
-  static ReplaceStmt *create(Context &ctx, llvm::SMRange loc, Expr *rootOp,
+  static ReplaceStmt *create(Context &ctx, SMRange loc, Expr *rootOp,
                              ArrayRef<Expr *> replExprs);
 
   /// Return the replacement values of this statement.
   MutableArrayRef<Expr *> getReplExprs() {
     return {getTrailingObjects<Expr *>(), numReplExprs};
   }
   ArrayRef<Expr *> getReplExprs() const {
     return const_cast<ReplaceStmt *>(this)->getReplExprs();
   }
 
 private:
-  ReplaceStmt(llvm::SMRange loc, Expr *rootOp, unsigned numReplExprs)
+  ReplaceStmt(SMRange loc, Expr *rootOp, unsigned numReplExprs)
       : Base(loc, rootOp), numReplExprs(numReplExprs) {}
 
   /// The number of replacement values within this statement.
   unsigned numReplExprs;
 
   /// TrailingObject utilities.
   friend class llvm::TrailingObjects<ReplaceStmt, Expr *>;
 };
 
 //===----------------------------------------------------------------------===//
 // RewriteStmt
 
 /// This statement represents an operation rewrite that contains a block of
 /// nested rewrite commands. This allows for building more complex operation
 /// rewrites that span across multiple statements, which may be unconnected.
 class RewriteStmt final : public Node::NodeBase<RewriteStmt, OpRewriteStmt> {
 public:
-  static RewriteStmt *create(Context &ctx, llvm::SMRange loc, Expr *rootOp,
+  static RewriteStmt *create(Context &ctx, SMRange loc, Expr *rootOp,
                              CompoundStmt *rewriteBody);
 
   /// Return the compound rewrite body.
   CompoundStmt *getRewriteBody() const { return rewriteBody; }
 
 private:
-  RewriteStmt(llvm::SMRange loc, Expr *rootOp, CompoundStmt *rewriteBody)
+  RewriteStmt(SMRange loc, Expr *rootOp, CompoundStmt *rewriteBody)
       : Base(loc, rootOp), rewriteBody(rewriteBody) {}
 
   /// The body of nested rewriters within this statement.
   CompoundStmt *rewriteBody;
 };
 
 //===----------------------------------------------------------------------===//
 // Expr
 //===----------------------------------------------------------------------===//
 
 /// This class represents a base AST Expression node.
 class Expr : public Stmt {
 public:
   /// Return the type of this expression.
   Type getType() const { return type; }
 
   /// Provide type casting support.
   static bool classof(const Node *node);
 
 protected:
-  Expr(TypeID typeID, llvm::SMRange loc, Type type)
+  Expr(TypeID typeID, SMRange loc, Type type)
       : Stmt(typeID, loc), type(type) {}
 
 private:
   /// The type of this expression.
   Type type;
 };
 
 //===----------------------------------------------------------------------===//
 // AttributeExpr
 //===----------------------------------------------------------------------===//
 
 /// This expression represents a literal MLIR Attribute, and contains the
 /// textual assembly format of that attribute.
 class AttributeExpr : public Node::NodeBase<AttributeExpr, Expr> {
 public:
-  static AttributeExpr *create(Context &ctx, llvm::SMRange loc,
+  static AttributeExpr *create(Context &ctx, SMRange loc,
                                StringRef value);
 
   /// Get the raw value of this expression. This is the textual assembly format
   /// of the MLIR Attribute.
   StringRef getValue() const { return value; }
 
 private:
-  AttributeExpr(Context &ctx, llvm::SMRange loc, StringRef value)
+  AttributeExpr(Context &ctx, SMRange loc, StringRef value)
       : Base(loc, AttributeType::get(ctx)), value(value) {}
 
   /// The value referenced by this expression.
   StringRef value;
 };
 
 //===----------------------------------------------------------------------===//
 // DeclRefExpr
 //===----------------------------------------------------------------------===//
 
 /// This expression represents a reference to a Decl node.
 class DeclRefExpr : public Node::NodeBase<DeclRefExpr, Expr> {
 public:
-  static DeclRefExpr *create(Context &ctx, llvm::SMRange loc, Decl *decl,
+  static DeclRefExpr *create(Context &ctx, SMRange loc, Decl *decl,
                              Type type);
 
   /// Get the decl referenced by this expression.
   Decl *getDecl() const { return decl; }
 
 private:
-  DeclRefExpr(llvm::SMRange loc, Decl *decl, Type type)
+  DeclRefExpr(SMRange loc, Decl *decl, Type type)
       : Base(loc, type), decl(decl) {}
 
   /// The decl referenced by this expression.
   Decl *decl;
 };
 
 //===----------------------------------------------------------------------===//
 // MemberAccessExpr
 //===----------------------------------------------------------------------===//
 
 /// This expression represents a named member or field access of a given parent
 /// expression.
 class MemberAccessExpr : public Node::NodeBase<MemberAccessExpr, Expr> {
 public:
-  static MemberAccessExpr *create(Context &ctx, llvm::SMRange loc,
+  static MemberAccessExpr *create(Context &ctx, SMRange loc,
                                   const Expr *parentExpr, StringRef memberName,
                                   Type type);
 
   /// Get the parent expression of this access.
   const Expr *getParentExpr() const { return parentExpr; }
 
   /// Return the name of the member being accessed.
   StringRef getMemberName() const { return memberName; }
 
 private:
-  MemberAccessExpr(llvm::SMRange loc, const Expr *parentExpr,
+  MemberAccessExpr(SMRange loc, const Expr *parentExpr,
                    StringRef memberName, Type type)
       : Base(loc, type), parentExpr(parentExpr), memberName(memberName) {}
 
   /// The parent expression of this access.
   const Expr *parentExpr;
 
   /// The name of the member being accessed from the parent.
   StringRef memberName;
 };
 
 //===----------------------------------------------------------------------===//
 // AllResultsMemberAccessExpr
 
 /// This class represents an instance of MemberAccessExpr that references all
 /// results of an operation.
 class AllResultsMemberAccessExpr : public MemberAccessExpr {
 public:
   /// Return the member name used for the "all-results" access.
   static StringRef getMemberName() { return "$results"; }
 
-  static AllResultsMemberAccessExpr *create(Context &ctx, llvm::SMRange loc,
+  static AllResultsMemberAccessExpr *create(Context &ctx, SMRange loc,
                                             const Expr *parentExpr, Type type) {
     return cast<AllResultsMemberAccessExpr>(
         MemberAccessExpr::create(ctx, loc, parentExpr, getMemberName(), type));
   }
 
   /// Provide type casting support.
   static bool classof(const Node *node) {
     const MemberAccessExpr *memAccess = dyn_cast<MemberAccessExpr>(node);
     return memAccess && memAccess->getMemberName() == getMemberName();
   }
 };
 
 //===----------------------------------------------------------------------===//
 // OperationExpr
 //===----------------------------------------------------------------------===//
 
 /// This expression represents the structural form of an MLIR Operation. It
 /// represents either an input operation to match, or an operation to create
 /// within a rewrite.
 class OperationExpr final
     : public Node::NodeBase<OperationExpr, Expr>,
       private llvm::TrailingObjects<OperationExpr, Expr *,
                                     NamedAttributeDecl *> {
 public:
-  static OperationExpr *create(Context &ctx, llvm::SMRange loc,
+  static OperationExpr *create(Context &ctx, SMRange loc,
                                const OpNameDecl *nameDecl,
                                ArrayRef<Expr *> operands,
                                ArrayRef<Expr *> resultTypes,
                                ArrayRef<NamedAttributeDecl *> attributes);
 
   /// Return the name of the operation, or None if there isn't one.
   Optional<StringRef> getName() const;
 
   /// Return the declaration of the operation name.
   const OpNameDecl *getNameDecl() const { return nameDecl; }
 
   /// Return the location of the name of the operation expression, or an invalid
   /// location if there isn't a name.
-  llvm::SMRange getNameLoc() const { return nameLoc; }
+  SMRange getNameLoc() const { return nameLoc; }
 
   /// Return the operands of this operation.
   MutableArrayRef<Expr *> getOperands() {
     return {getTrailingObjects<Expr *>(), numOperands};
   }
   ArrayRef<Expr *> getOperands() const {
     return const_cast<OperationExpr *>(this)->getOperands();
   }
public:
   MutableArrayRef<NamedAttributeDecl *> getAttributes() {
     return {getTrailingObjects<NamedAttributeDecl *>(), numAttributes};
   }
   MutableArrayRef<NamedAttributeDecl *> getAttributes() const {
     return const_cast<OperationExpr *>(this)->getAttributes();
   }
 
 private:
-  OperationExpr(llvm::SMRange loc, Type type, const OpNameDecl *nameDecl,
+  OperationExpr(SMRange loc, Type type, const OpNameDecl *nameDecl,
                 unsigned numOperands, unsigned numResultTypes,
-                unsigned numAttributes, llvm::SMRange nameLoc)
+                unsigned numAttributes, SMRange nameLoc)
       : Base(loc, type), nameDecl(nameDecl), numOperands(numOperands),
         numResultTypes(numResultTypes), numAttributes(numAttributes),
         nameLoc(nameLoc) {}
 
   /// The name decl of this expression.
   const OpNameDecl *nameDecl;
 
   /// The number of operands, result types, and attributes of the operation.
   unsigned numOperands, numResultTypes, numAttributes;
 
   /// The location of the operation name in the expression if it has a name.
-  llvm::SMRange nameLoc;
+  SMRange nameLoc;
 
   /// TrailingObject utilities.
   friend llvm::TrailingObjects<OperationExpr, Expr *, NamedAttributeDecl *>;
   size_t numTrailingObjects(OverloadToken<Expr *>) const {
     return numOperands + numResultTypes;
   }
 };
 
 //===----------------------------------------------------------------------===//
 // TupleExpr
 //===----------------------------------------------------------------------===//
 
 /// This expression builds a tuple from a set of element values.
 class TupleExpr final : public Node::NodeBase<TupleExpr, Expr>,
                         private llvm::TrailingObjects<TupleExpr, Expr *> {
 public:
-  static TupleExpr *create(Context &ctx, llvm::SMRange loc,
+  static TupleExpr *create(Context &ctx, SMRange loc,
                            ArrayRef<Expr *> elements,
                            ArrayRef<StringRef> elementNames);
 
   /// Return the element expressions of this tuple.
   MutableArrayRef<Expr *> getElements() {
     return {getTrailingObjects<Expr *>(), getType().size()};
   }
   ArrayRef<Expr *> getElements() const {
     return const_cast<TupleExpr *>(this)->getElements();
   }
 
   /// Return the tuple result type of this expression.
   TupleType getType() const { return Base::getType().cast<TupleType>(); }
 
 private:
-  TupleExpr(llvm::SMRange loc, TupleType type) : Base(loc, type) {}
+  TupleExpr(SMRange loc, TupleType type) : Base(loc, type) {}
 
   /// TrailingObject utilities.
   friend class llvm::TrailingObjects<TupleExpr, Expr *>;
 };
 
 //===----------------------------------------------------------------------===//
 // TypeExpr
 //===----------------------------------------------------------------------===//
 
 /// This expression represents a literal MLIR Type, and contains the textual
 /// assembly format of that type.
 class TypeExpr : public Node::NodeBase<TypeExpr, Expr> {
 public:
-  static TypeExpr *create(Context &ctx, llvm::SMRange loc, StringRef value);
+  static TypeExpr *create(Context &ctx, SMRange loc, StringRef value);
 
   /// Get the raw value of this expression. This is the textual assembly format
   /// of the MLIR Type.
   StringRef getValue() const { return value; }
 
 private:
-  TypeExpr(Context &ctx, llvm::SMRange loc, StringRef value)
+  TypeExpr(Context &ctx, SMRange loc, StringRef value)
       : Base(loc, TypeType::get(ctx)), value(value) {}
 
   /// The value referenced by this expression.
   StringRef value;
 };
 
 //===----------------------------------------------------------------------===//
 // Decl
 //===----------------------------------------------------------------------===//
 
 /// This class represents the base Decl node.
 class Decl : public Node {
 public:
   /// Return the name of the decl, or nullptr if it doesn't have one.
   const Name *getName() const { return name; }
 
   /// Provide type casting support.
   static bool classof(const Node *node);
 
 protected:
-  Decl(TypeID typeID, llvm::SMRange loc, const Name *name = nullptr)
+  Decl(TypeID typeID, SMRange loc, const Name *name = nullptr)
       : Node(typeID, loc), name(name) {}
 
 private:
   /// The name of the decl. This is optional for some decls, such as
   /// PatternDecl.
   const Name *name;
 };
 
 //===----------------------------------------------------------------------===//
 // ConstraintDecl
 //===----------------------------------------------------------------------===//
 
 /// This class represents the base of all AST Constraint decls. Constraints
 /// apply matcher conditions to, and define the type of PDLL variables.
 class ConstraintDecl : public Decl {
 public:
   /// Provide type casting support.
   static bool classof(const Node *node);
 
 protected:
-  ConstraintDecl(TypeID typeID, llvm::SMRange loc, const Name *name = nullptr)
+  ConstraintDecl(TypeID typeID, SMRange loc, const Name *name = nullptr)
       : Decl(typeID, loc, name) {}
 };
 
 /// This class represents a reference to a constraint, and contains a constraint
 /// and the location of the reference.
 struct ConstraintRef {
-  ConstraintRef(const ConstraintDecl *constraint, llvm::SMRange refLoc)
+  ConstraintRef(const ConstraintDecl *constraint, SMRange refLoc)
       : constraint(constraint), referenceLoc(refLoc) {}
   explicit ConstraintRef(const ConstraintDecl *constraint)
       : ConstraintRef(constraint, constraint->getLoc()) {}
 
   const ConstraintDecl *constraint;
-  llvm::SMRange referenceLoc;
+  SMRange referenceLoc;
 };
 
 //===----------------------------------------------------------------------===//
 // CoreConstraintDecl
 //===----------------------------------------------------------------------===//
 
 /// This class represents the base of all "core" constraints. Core constraints
 /// are those that generally represent a concrete IR construct, such as
 /// `Type`s or `Value`s.
 class CoreConstraintDecl : public ConstraintDecl {
 public:
   /// Provide type casting support.
   static bool classof(const Node *node);
 
 protected:
-  CoreConstraintDecl(TypeID typeID, llvm::SMRange loc,
+  CoreConstraintDecl(TypeID typeID, SMRange loc,
                      const Name *name = nullptr)
       : ConstraintDecl(typeID, loc, name) {}
 };
 
 //===----------------------------------------------------------------------===//
 // AttrConstraintDecl
 
 /// The class represents an Attribute constraint, and constrains a variable to
 /// be an Attribute.
 class AttrConstraintDecl
     : public Node::NodeBase<AttrConstraintDecl, CoreConstraintDecl> {
 public:
-  static AttrConstraintDecl *create(Context &ctx, llvm::SMRange loc,
+  static AttrConstraintDecl *create(Context &ctx, SMRange loc,
                                     Expr *typeExpr = nullptr);
 
   /// Return the optional type the attribute is constrained to.
   Expr *getTypeExpr() { return typeExpr; }
   const Expr *getTypeExpr() const { return typeExpr; }
 
 protected:
-  AttrConstraintDecl(llvm::SMRange loc, Expr *typeExpr)
+  AttrConstraintDecl(SMRange loc, Expr *typeExpr)
       : Base(loc), typeExpr(typeExpr) {}
 
   /// An optional type that the attribute is constrained to.
   Expr *typeExpr;
 };
 
 //===----------------------------------------------------------------------===//
 // OpConstraintDecl
 
 /// The class represents an Operation constraint, and constrains a variable to
 /// be an Operation.
 class OpConstraintDecl
     : public Node::NodeBase<OpConstraintDecl, CoreConstraintDecl> {
 public:
-  static OpConstraintDecl *create(Context &ctx, llvm::SMRange loc,
+  static OpConstraintDecl *create(Context &ctx, SMRange loc,
                                   const OpNameDecl *nameDecl = nullptr);
 
   /// Return the name of the operation, or None if there isn't one.
   Optional<StringRef> getName() const;
 
   /// Return the declaration of the operation name.
   const OpNameDecl *getNameDecl() const { return nameDecl; }
 
 protected:
-  explicit OpConstraintDecl(llvm::SMRange loc, const OpNameDecl *nameDecl)
+  explicit OpConstraintDecl(SMRange loc, const OpNameDecl *nameDecl)
       : Base(loc), nameDecl(nameDecl) {}
 
   /// The operation name of this constraint.
   const OpNameDecl *nameDecl;
 };
 
 //===----------------------------------------------------------------------===//
 // TypeConstraintDecl
 
 /// The class represents a Type constraint, and constrains a variable to be a
 /// Type.
 class TypeConstraintDecl
     : public Node::NodeBase<TypeConstraintDecl, CoreConstraintDecl> {
 public:
-  static TypeConstraintDecl *create(Context &ctx, llvm::SMRange loc);
+  static TypeConstraintDecl *create(Context &ctx, SMRange loc);
 
 protected:
   using Base::Base;
 };
 
 //===----------------------------------------------------------------------===//
 // TypeRangeConstraintDecl
 
 /// The class represents a TypeRange constraint, and constrains a variable to be
 /// a TypeRange.
 class TypeRangeConstraintDecl
     : public Node::NodeBase<TypeRangeConstraintDecl, CoreConstraintDecl> {
 public:
-  static TypeRangeConstraintDecl *create(Context &ctx, llvm::SMRange loc);
+  static TypeRangeConstraintDecl *create(Context &ctx, SMRange loc);
 
 protected:
   using Base::Base;
 };
 
 //===----------------------------------------------------------------------===//
 // ValueConstraintDecl
 
 /// The class represents a Value constraint, and constrains a variable to be a
 /// Value.
 class ValueConstraintDecl
     : public Node::NodeBase<ValueConstraintDecl, CoreConstraintDecl> {
 public:
-  static ValueConstraintDecl *create(Context &ctx, llvm::SMRange loc,
+  static ValueConstraintDecl *create(Context &ctx, SMRange loc,
                                      Expr *typeExpr);
 
   /// Return the optional type the value is constrained to.
   Expr *getTypeExpr() { return typeExpr; }
   const Expr *getTypeExpr() const { return typeExpr; }
 
 protected:
-  ValueConstraintDecl(llvm::SMRange loc, Expr *typeExpr)
+  ValueConstraintDecl(SMRange loc, Expr *typeExpr)
       : Base(loc), typeExpr(typeExpr) {}
 
   /// An optional type that the value is constrained to.
   Expr *typeExpr;
 };
 
 //===----------------------------------------------------------------------===//
 // ValueRangeConstraintDecl
 
 /// The class represents a ValueRange constraint, and constrains a variable to
 /// be a ValueRange.
 class ValueRangeConstraintDecl
     : public Node::NodeBase<ValueRangeConstraintDecl, CoreConstraintDecl> {
 public:
-  static ValueRangeConstraintDecl *create(Context &ctx, llvm::SMRange loc,
+  static ValueRangeConstraintDecl *create(Context &ctx, SMRange loc,
                                           Expr *typeExpr);
 
   /// Return the optional type the value range is constrained to.
   Expr *getTypeExpr() { return typeExpr; }
   const Expr *getTypeExpr() const { return typeExpr; }
 
 protected:
-  ValueRangeConstraintDecl(llvm::SMRange loc, Expr *typeExpr)
+  ValueRangeConstraintDecl(SMRange loc, Expr *typeExpr)
       : Base(loc), typeExpr(typeExpr) {}
 
   /// An optional type that the value range is constrained to.
   Expr *typeExpr;
 };
 
 //===----------------------------------------------------------------------===//
 // NamedAttributeDecl

 //===----------------------------------------------------------------------===//
 // OpNameDecl
 //===----------------------------------------------------------------------===//
 
 /// This Decl represents an OperationName.
 class OpNameDecl : public Node::NodeBase<OpNameDecl, Decl> {
 public:
   static OpNameDecl *create(Context &ctx, const Name &name);
-  static OpNameDecl *create(Context &ctx, llvm::SMRange loc);
+  static OpNameDecl *create(Context &ctx, SMRange loc);
 
   /// Return the name of this operation, or none if the name is unknown.
   Optional<StringRef> getName() const {
     const Name *name = Decl::getName();
     return name ? Optional<StringRef>(name->getName()) : llvm::None;
   }
 
 private:
   explicit OpNameDecl(const Name &name) : Base(name.getLoc(), &name) {}
-  explicit OpNameDecl(llvm::SMRange loc) : Base(loc) {}
+  explicit OpNameDecl(SMRange loc) : Base(loc) {}
 };
 
 //===----------------------------------------------------------------------===//
 // PatternDecl
 //===----------------------------------------------------------------------===//
 
 /// This Decl represents a single Pattern.
 class PatternDecl : public Node::NodeBase<PatternDecl, Decl> {
 public:
-  static PatternDecl *create(Context &ctx, llvm::SMRange location,
+  static PatternDecl *create(Context &ctx, SMRange location,
                              const Name *name, Optional<uint16_t> benefit,
                              bool hasBoundedRecursion,
                              const CompoundStmt *body);
 
   /// Return the benefit of this pattern if specified, or None.
   Optional<uint16_t> getBenefit() const { return benefit; }
 
   /// Return if this pattern has bounded rewrite recursion.
   bool hasBoundedRewriteRecursion() const { return hasBoundedRecursion; }
 
   /// Return the body of this pattern.
   const CompoundStmt *getBody() const { return patternBody; }
 
   /// Return the root rewrite statement of this pattern.
   const OpRewriteStmt *getRootRewriteStmt() const {
     return cast<OpRewriteStmt>(patternBody->getChildren().back());
   }
 
 private:
-  PatternDecl(llvm::SMRange loc, const Name *name, Optional<uint16_t> benefit,
+  PatternDecl(SMRange loc, const Name *name, Optional<uint16_t> benefit,
               bool hasBoundedRecursion, const CompoundStmt *body)
       : Base(loc, name), benefit(benefit),
         hasBoundedRecursion(hasBoundedRecursion), patternBody(body) {}
 
   /// The benefit of the pattern if it was explicitly specified, None otherwise.
   Optional<uint16_t> benefit;
 
   /// If the pattern has properly bounded rewrite recursion or not.

 //===----------------------------------------------------------------------===//
 // Module
 //===----------------------------------------------------------------------===//
 
 /// This class represents a top-level AST module.
 class Module final : public Node::NodeBase<Module, Node>,
                      private llvm::TrailingObjects<Module, Decl *> {
 public:
-  static Module *create(Context &ctx, llvm::SMLoc loc,
+  static Module *create(Context &ctx, SMLoc loc,
                         ArrayRef<Decl *> children);
 
   /// Return the children of this module.
   MutableArrayRef<Decl *> getChildren() {
     return {getTrailingObjects<Decl *>(), numChildren};
   }
   ArrayRef<Decl *> getChildren() const {
     return const_cast<Module *>(this)->getChildren();
   }
 
 private:
-  Module(llvm::SMLoc loc, unsigned numChildren)
-      : Base(llvm::SMRange{loc, loc}), numChildren(numChildren) {}
+  Module(SMLoc loc, unsigned numChildren)
+      : Base(SMRange{loc, loc}), numChildren(numChildren) {}
 
   /// The number of decls held by this module.
   unsigned numChildren;
 
   /// Allow access to various internals.
   friend llvm::TrailingObjects<Module, Decl *>;
 };
 

mlir/lib/Dialect/Affine/IR/AffineOps.cpp

if (!boundOpInfos.empty()) {
     // for storage. Analysis passes may expand it into a multi-dimensional map
     // if desired.
     AffineMap map = builder.getSymbolIdentityMap();
     result.addAttribute(boundAttrName, AffineMapAttr::get(map));
     return success();
   }
 
   // Get the attribute location.
-  llvm::SMLoc attrLoc = p.getCurrentLocation();
+  SMLoc attrLoc = p.getCurrentLocation();
 
   Attribute boundAttr;
   if (p.parseAttribute(boundAttr, builder.getIndexType(), boundAttrName,
                        result.attributes))
     return failure();
 
   // Parse full form - affine map followed by dim and symbol list.
   if (auto affineMapAttr = boundAttr.dyn_cast<AffineMapAttr>()) {
if (parseBound(/*isLower=*/true, result, parser) ||
     return failure();
 
   // Parse the optional loop step, we default to 1 if one is not present.
   if (parser.parseOptionalKeyword("step")) {
     result.addAttribute(
         AffineForOp::getStepAttrName(),
         builder.getIntegerAttr(builder.getIndexType(), /*value=*/1));
   } else {
-    llvm::SMLoc stepLoc = parser.getCurrentLocation();
+    SMLoc stepLoc = parser.getCurrentLocation();
     IntegerAttr stepAttr;
     if (parser.parseAttribute(stepAttr, builder.getIndexType(),
                               AffineForOp::getStepAttrName().data(),
                               result.attributes))
       return failure();
 
     if (stepAttr.getValue().getSExtValue() < 0)
       return parser.emitError(

mlir/lib/Dialect/DLTI/DLTI.cpp

 /// Parses an attribute with syntax:
 ///   attr ::= `#target.` `dl_entry` `<` (type | quoted-string) `,` attr `>`
 DataLayoutEntryAttr DataLayoutEntryAttr::parse(AsmParser &parser) {
   if (failed(parser.parseLess()))
     return {};
 
   Type type = nullptr;
   std::string identifier;
-  llvm::SMLoc idLoc = parser.getCurrentLocation();
+  SMLoc idLoc = parser.getCurrentLocation();
   OptionalParseResult parsedType = parser.parseOptionalType(type);
   if (parsedType.hasValue() && failed(parsedType.getValue()))
     return {};
   if (!parsedType.hasValue()) {
     OptionalParseResult parsedString = parser.parseOptionalString(&identifier);
     if (!parsedString.hasValue() || failed(parsedString.getValue())) {
       parser.emitError(idLoc) << "expected a type or a quoted string";
       return {};

mlir/lib/Dialect/EmitC/IR/EmitC.cpp

 
 #define GET_ATTRDEF_CLASSES
 #include "mlir/Dialect/EmitC/IR/EmitCAttributes.cpp.inc"
 
 Attribute emitc::OpaqueAttr::parse(AsmParser &parser, Type type) {
   if (parser.parseLess())
     return Attribute();
   std::string value;
-  llvm::SMLoc loc = parser.getCurrentLocation();
+  SMLoc loc = parser.getCurrentLocation();
   if (parser.parseOptionalString(&value)) {
     parser.emitError(loc) << "expected string";
     return Attribute();
   }
   if (parser.parseGreater())
     return Attribute();
   return get(parser.getContext(), value);
 }

 
 #define GET_TYPEDEF_CLASSES
 #include "mlir/Dialect/EmitC/IR/EmitCTypes.cpp.inc"
 
 Type emitc::OpaqueType::parse(AsmParser &parser) {
   if (parser.parseLess())
     return Type();
   std::string value;
-  llvm::SMLoc loc = parser.getCurrentLocation();
+  SMLoc loc = parser.getCurrentLocation();
   if (parser.parseOptionalString(&value) || value.empty()) {
     parser.emitError(loc) << "expected non empty string";
     return Type();
   }
   if (parser.parseGreater())
     return Type();
   return get(parser.getContext(), value);
 }
 
 void emitc::OpaqueType::print(AsmPrinter &printer) const {
   printer << "<\"";
   llvm::printEscapedString(getValue(), printer.getStream());
   printer << "\">";
 }

mlir/lib/Dialect/GPU/IR/GPUDialect.cpp

if (parser.parseKeyword(&keyword))
     return Type();
   MLIRContext *context = getContext();
 
   // Handle 'async token' types.
   if (keyword == "async.token")
     return AsyncTokenType::get(context);
 
   if (keyword == "mma_matrix") {
-    llvm::SMLoc beginLoc = parser.getNameLoc();
+    SMLoc beginLoc = parser.getNameLoc();
 
     // Parse '<'.
     if (parser.parseLess())
       return nullptr;
 
     // Parse the size and elementType.
     SmallVector<int64_t> shape;
     Type elementType;

mlir/lib/Dialect/GPU/Transforms/SerializeToHsaco.cpp

SerializeToHsacoPass::assembleIsa(const std::string &isa) {
   const llvm::Target *target =
       llvm::TargetRegistry::lookupTarget(triple.normalize(), error);
   if (!target) {
     emitError(loc, Twine("failed to lookup target: ") + error);
     return {};
   }
 
   llvm::SourceMgr srcMgr;
   srcMgr.AddNewSourceBuffer(llvm::MemoryBuffer::getMemBuffer(isa),
-                            llvm::SMLoc());
+                            SMLoc());
 
   const llvm::MCTargetOptions mcOptions;
   std::unique_ptr<llvm::MCRegisterInfo> mri(
       target->createMCRegInfo(this->triple));
   std::unique_ptr<llvm::MCAsmInfo> mai(
       target->createMCAsmInfo(*mri, this->triple, mcOptions));
   mai->setRelaxELFRelocations(true);
   std::unique_ptr<llvm::MCSubtargetInfo> sti(

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

 //                 attribute-dict? `:` type
 template <typename CmpPredicateType>
 static ParseResult parseCmpOp(OpAsmParser &parser, OperationState &result) {
   Builder &builder = parser.getBuilder();
 
   StringAttr predicateAttr;
   OpAsmParser::OperandType lhs, rhs;
   Type type;
-  llvm::SMLoc predicateLoc, trailingTypeLoc;
+  SMLoc predicateLoc, trailingTypeLoc;
   if (parser.getCurrentLocation(&predicateLoc) ||
       parser.parseAttribute(predicateAttr, "predicate", result.attributes) ||
       parser.parseOperand(lhs) || parser.parseComma() ||
       parser.parseOperand(rhs) ||
       parser.parseOptionalAttrDict(result.attributes) || parser.parseColon() ||
       parser.getCurrentLocation(&trailingTypeLoc) || parser.parseType(type) ||
       parser.resolveOperand(lhs, type, result.operands) ||
       parser.resolveOperand(rhs, type, result.operands))
static void printAllocaOp(OpAsmPrinter &p, AllocaOp &op) {
   p << " : " << funcTy;
 }
 
 // <operation> ::= `llvm.alloca` ssa-use `x` type attribute-dict?
 //                 `:` type `,` type
 static ParseResult parseAllocaOp(OpAsmParser &parser, OperationState &result) {
   OpAsmParser::OperandType arraySize;
   Type type, elemType;
-  llvm::SMLoc trailingTypeLoc;
+  SMLoc trailingTypeLoc;
   if (parser.parseOperand(arraySize) || parser.parseKeyword("x") ||
       parser.parseType(elemType) ||
       parser.parseOptionalAttrDict(result.attributes) || parser.parseColon() ||
       parser.getCurrentLocation(&trailingTypeLoc) || parser.parseType(type))
     return failure();
 
   Optional<NamedAttribute> alignmentAttr =
       result.attributes.getNamed("alignment");
static void printLoadOp(OpAsmPrinter &p, LoadOp &op) {
   p << op.getAddr();
   p.printOptionalAttrDict(op->getAttrs(), {kVolatileAttrName});
   p << " : " << op.getAddr().getType();
 }
 
 // Extract the pointee type from the LLVM pointer type wrapped in MLIR.  Return
 // the resulting type wrapped in MLIR, or nullptr on error.
 static Type getLoadStoreElementType(OpAsmParser &parser, Type type,
-                                    llvm::SMLoc trailingTypeLoc) {
+                                    SMLoc trailingTypeLoc) {
   auto llvmTy = type.dyn_cast<LLVM::LLVMPointerType>();
   if (!llvmTy)
     return parser.emitError(trailingTypeLoc, "expected LLVM pointer type"),
            nullptr;
   return llvmTy.getElementType();
 }
 
 // <operation> ::= `llvm.load` `volatile` ssa-use attribute-dict? `:` type
 static ParseResult parseLoadOp(OpAsmParser &parser, OperationState &result) {
   OpAsmParser::OperandType addr;
   Type type;
-  llvm::SMLoc trailingTypeLoc;
+  SMLoc trailingTypeLoc;
 
   if (succeeded(parser.parseOptionalKeyword("volatile")))
     result.addAttribute(kVolatileAttrName, parser.getBuilder().getUnitAttr());
 
   if (parser.parseOperand(addr) ||
       parser.parseOptionalAttrDict(result.attributes) || parser.parseColon() ||
       parser.getCurrentLocation(&trailingTypeLoc) || parser.parseType(type) ||
       parser.resolveOperand(addr, type, result.operands))
static void printStoreOp(OpAsmPrinter &p, StoreOp &op) {
   p << " : " << op.getAddr().getType();
 }
 
 // <operation> ::= `llvm.store` `volatile` ssa-use `,` ssa-use
 //                 attribute-dict? `:` type
 static ParseResult parseStoreOp(OpAsmParser &parser, OperationState &result) {
   OpAsmParser::OperandType addr, value;
   Type type;
-  llvm::SMLoc trailingTypeLoc;
+  SMLoc trailingTypeLoc;
 
   if (succeeded(parser.parseOptionalKeyword("volatile")))
     result.addAttribute(kVolatileAttrName, parser.getBuilder().getUnitAttr());
 
   if (parser.parseOperand(value) || parser.parseComma() ||
       parser.parseOperand(addr) ||
       parser.parseOptionalAttrDict(result.attributes) || parser.parseColon() ||
       parser.getCurrentLocation(&trailingTypeLoc) || parser.parseType(type))

 /// <operation> ::= `llvm.invoke` (function-id | ssa-use) `(` ssa-use-list `)`
 ///                  `to` bb-id (`[` ssa-use-and-type-list `]`)?
 ///                  `unwind` bb-id (`[` ssa-use-and-type-list `]`)?
 ///                  attribute-dict? `:` function-type
 static ParseResult parseInvokeOp(OpAsmParser &parser, OperationState &result) {
   SmallVector<OpAsmParser::OperandType, 8> operands;
   FunctionType funcType;
   SymbolRefAttr funcAttr;
-  llvm::SMLoc trailingTypeLoc;
+  SMLoc trailingTypeLoc;
   Block *normalDest, *unwindDest;
   SmallVector<Value, 4> normalOperands, unwindOperands;
   Builder &builder = parser.getBuilder();
 
   // Parse an operand list that will, in practice, contain 0 or 1 operand.  In
   // case of an indirect call, there will be 1 operand before `(`.  In case of a
   // direct call, there will be no operands and the parser will stop at the
   // function identifier without complaining.

 }
 
 // <operation> ::= `llvm.call` (function-id | ssa-use) `(` ssa-use-list `)`
 //                 attribute-dict? `:` function-type
 static ParseResult parseCallOp(OpAsmParser &parser, OperationState &result) {
   SmallVector<OpAsmParser::OperandType, 8> operands;
   Type type;
   SymbolRefAttr funcAttr;
-  llvm::SMLoc trailingTypeLoc;
+  SMLoc trailingTypeLoc;
 
   // Parse an operand list that will, in practice, contain 0 or 1 operand.  In
   // case of an indirect call, there will be 1 operand before `(`.  In case of a
   // direct call, there will be no operands and the parser will stop at the
   // function identifier without complaining.
   if (parser.parseOperandList(operands))
     return failure();
   bool isDirect = operands.empty();
static void printExtractElementOp(OpAsmPrinter &p, ExtractElementOp &op) {
   p.printOptionalAttrDict(op->getAttrs());
   p << " : " << op.getVector().getType();
 }
 
 // <operation> ::= `llvm.extractelement` ssa-use `, ` ssa-use
 //                 attribute-dict? `:` type
 static ParseResult parseExtractElementOp(OpAsmParser &parser,
                                          OperationState &result) {
-  llvm::SMLoc loc;
+  SMLoc loc;
   OpAsmParser::OperandType vector, position;
   Type type, positionType;
   if (parser.getCurrentLocation(&loc) || parser.parseOperand(vector) ||
       parser.parseLSquare() || parser.parseOperand(position) ||
       parser.parseColonType(positionType) || parser.parseRSquare() ||
       parser.parseOptionalAttrDict(result.attributes) ||
       parser.parseColonType(type) ||
       parser.resolveOperand(vector, type, result.operands) ||

 
 // Extract the type at `position` in the wrapped LLVM IR aggregate type
 // `containerType`.  Position is an integer array attribute where each value
 // is a zero-based position of the element in the aggregate type.  Return the
 // resulting type wrapped in MLIR, or nullptr on error.
 static Type getInsertExtractValueElementType(OpAsmParser &parser,
                                              Type containerType,
                                              ArrayAttr positionAttr,
-                                             llvm::SMLoc attributeLoc,
-                                             llvm::SMLoc typeLoc) {
+                                             SMLoc attributeLoc,
+                                             SMLoc typeLoc) {
   Type llvmType = containerType;
   if (!isCompatibleType(containerType))
     return parser.emitError(typeLoc, "expected LLVM IR Dialect type"), nullptr;
 
   // Infer the element type from the structure type: iteratively step inside the
   // type by taking the element type, indexed by the position attribute for
   // structures.  Check the position index before accessing, it is supposed to
   // be in bounds.

 // <operation> ::= `llvm.extractvalue` ssa-use
 //                 `[` integer-literal (`,` integer-literal)* `]`
 //                 attribute-dict? `:` type
 static ParseResult parseExtractValueOp(OpAsmParser &parser,
                                        OperationState &result) {
   OpAsmParser::OperandType container;
   Type containerType;
   ArrayAttr positionAttr;
-  llvm::SMLoc attributeLoc, trailingTypeLoc;
+  SMLoc attributeLoc, trailingTypeLoc;
 
   if (parser.parseOperand(container) ||
       parser.getCurrentLocation(&attributeLoc) ||
       parser.parseAttribute(positionAttr, "position", result.attributes) ||
       parser.parseOptionalAttrDict(result.attributes) || parser.parseColon() ||
       parser.getCurrentLocation(&trailingTypeLoc) ||
       parser.parseType(containerType) ||
       parser.resolveOperand(container, containerType, result.operands))
static void printInsertElementOp(OpAsmPrinter &p, InsertElementOp &op) {
   p.printOptionalAttrDict(op->getAttrs());
   p << " : " << op.getVector().getType();
 }
 
 // <operation> ::= `llvm.insertelement` ssa-use `,` ssa-use `,` ssa-use
 //                 attribute-dict? `:` type
 static ParseResult parseInsertElementOp(OpAsmParser &parser,
                                         OperationState &result) {
-  llvm::SMLoc loc;
+  SMLoc loc;
   OpAsmParser::OperandType vector, value, position;
   Type vectorType, positionType;
   if (parser.getCurrentLocation(&loc) || parser.parseOperand(value) ||
       parser.parseComma() || parser.parseOperand(vector) ||
       parser.parseLSquare() || parser.parseOperand(position) ||
       parser.parseColonType(positionType) || parser.parseRSquare() ||
       parser.parseOptionalAttrDict(result.attributes) ||
       parser.parseColonType(vectorType))

 // <operation> ::= `llvm.insertvaluevalue` ssa-use `,` ssa-use
 //                 `[` integer-literal (`,` integer-literal)* `]`
 //                 attribute-dict? `:` type
 static ParseResult parseInsertValueOp(OpAsmParser &parser,
                                       OperationState &result) {
   OpAsmParser::OperandType container, value;
   Type containerType;
   ArrayAttr positionAttr;
-  llvm::SMLoc attributeLoc, trailingTypeLoc;
+  SMLoc attributeLoc, trailingTypeLoc;
 
   if (parser.parseOperand(value) || parser.parseComma() ||
       parser.parseOperand(container) ||
       parser.getCurrentLocation(&attributeLoc) ||
       parser.parseAttribute(positionAttr, "position", result.attributes) ||
       parser.parseOptionalAttrDict(result.attributes) || parser.parseColon() ||
       parser.getCurrentLocation(&trailingTypeLoc) ||
       parser.parseType(containerType))
static void printShuffleVectorOp(OpAsmPrinter &p, ShuffleVectorOp &op) {
   p << " : " << op.getV1().getType() << ", " << op.getV2().getType();
 }
 
 // <operation> ::= `llvm.shufflevector` ssa-use `, ` ssa-use
 //                 `[` integer-literal (`,` integer-literal)* `]`
 //                 attribute-dict? `:` type
 static ParseResult parseShuffleVectorOp(OpAsmParser &parser,
                                         OperationState &result) {
-  llvm::SMLoc loc;
+  SMLoc loc;
   OpAsmParser::OperandType v1, v2;
   ArrayAttr maskAttr;
   Type typeV1, typeV2;
   if (parser.getCurrentLocation(&loc) || parser.parseOperand(v1) ||
       parser.parseComma() || parser.parseOperand(v2) ||
       parser.parseAttribute(maskAttr, "mask", result.attributes) ||
       parser.parseOptionalAttrDict(result.attributes) ||
       parser.parseColonType(typeV1) || parser.parseComma() ||
void LLVMFuncOp::build(OpBuilder &builder, OperationState &result,
   function_interface_impl::addArgAndResultAttrs(builder, result, argAttrs,
                                                 /*resultAttrs=*/llvm::None);
 }
 
 // Builds an LLVM function type from the given lists of input and output types.
 // Returns a null type if any of the types provided are non-LLVM types, or if
 // there is more than one output type.
 static Type
-buildLLVMFunctionType(OpAsmParser &parser, llvm::SMLoc loc,
+buildLLVMFunctionType(OpAsmParser &parser, SMLoc loc,
                       ArrayRef<Type> inputs, ArrayRef<Type> outputs,
                       function_interface_impl::VariadicFlag variadicFlag) {
   Builder &b = parser.getBuilder();
   if (outputs.size() > 1) {
     parser.emitError(loc, "failed to construct function type: expected zero or "
                           "one function result");
     return {};
   }

 //===----------------------------------------------------------------------===//
 
 // Helper function to parse a keyword into the specified attribute named by
 // `attrName`. The keyword must match one of the string values defined by the
 // AtomicBinOp enum. The resulting I64 attribute is added to the `result`
 // state.
 static ParseResult parseAtomicBinOp(OpAsmParser &parser, OperationState &result,
                                     StringRef attrName) {
-  llvm::SMLoc loc;
+  SMLoc loc;
   StringRef keyword;
   if (parser.getCurrentLocation(&loc) || parser.parseKeyword(&keyword))
     return failure();
 
   // Replace the keyword `keyword` with an integer attribute.
   auto kind = symbolizeAtomicBinOp(keyword);
   if (!kind) {
     return parser.emitError(loc)

 
 // Helper function to parse a keyword into the specified attribute named by
 // `attrName`. The keyword must match one of the string values defined by the
 // AtomicOrdering enum. The resulting I64 attribute is added to the `result`
 // state.
 static ParseResult parseAtomicOrdering(OpAsmParser &parser,
                                        OperationState &result,
                                        StringRef attrName) {
-  llvm::SMLoc loc;
+  SMLoc loc;
   StringRef ordering;
   if (parser.getCurrentLocation(&loc) || parser.parseKeyword(&ordering))
     return failure();
 
   // Replace the keyword `ordering` with an integer attribute.
   auto kind = symbolizeAtomicOrdering(ordering);
   if (!kind) {
     return parser.emitError(loc)

mlir/lib/Dialect/LLVMIR/IR/LLVMTypeSyntax.cpp

 // Parsing.
 //===----------------------------------------------------------------------===//
 
 static ParseResult dispatchParse(AsmParser &parser, Type &type);
 
 /// Parses an LLVM dialect function type.
 ///   llvm-type :: = `func<` llvm-type `(` llvm-type-list `...`? `)>`
 static LLVMFunctionType parseFunctionType(AsmParser &parser) {
-  llvm::SMLoc loc = parser.getCurrentLocation();
+  SMLoc loc = parser.getCurrentLocation();
   Type returnType;
   if (parser.parseLess() || dispatchParse(parser, returnType) ||
       parser.parseLParen())
     return LLVMFunctionType();
 
   // Function type without arguments.
   if (succeeded(parser.parseOptionalRParen())) {
     if (succeeded(parser.parseGreater()))
if (parser.parseOptionalRParen() || parser.parseOptionalGreater())
     return LLVMFunctionType();
   return parser.getChecked<LLVMFunctionType>(loc, returnType, argTypes,
                                              /*isVarArg=*/false);
 }
 
 /// Parses an LLVM dialect pointer type.
 ///   llvm-type ::= `ptr<` llvm-type (`,` integer)? `>`
 static LLVMPointerType parsePointerType(AsmParser &parser) {
-  llvm::SMLoc loc = parser.getCurrentLocation();
+  SMLoc loc = parser.getCurrentLocation();
   Type elementType;
   if (parser.parseLess() || dispatchParse(parser, elementType))
     return LLVMPointerType();
 
   unsigned addressSpace = 0;
   if (succeeded(parser.parseOptionalComma()) &&
       failed(parser.parseInteger(addressSpace)))
     return LLVMPointerType();
   if (failed(parser.parseGreater()))
     return LLVMPointerType();
   return parser.getChecked<LLVMPointerType>(loc, elementType, addressSpace);
 }
 
 /// Parses an LLVM dialect vector type.
 ///   llvm-type ::= `vec<` `? x`? integer `x` llvm-type `>`
 /// Supports both fixed and scalable vectors.
 static Type parseVectorType(AsmParser &parser) {
   SmallVector<int64_t, 2> dims;
-  llvm::SMLoc dimPos, typePos;
+  SMLoc dimPos, typePos;
   Type elementType;
-  llvm::SMLoc loc = parser.getCurrentLocation();
+  SMLoc loc = parser.getCurrentLocation();
   if (parser.parseLess() || parser.getCurrentLocation(&dimPos) ||
       parser.parseDimensionList(dims, /*allowDynamic=*/true) ||
       parser.getCurrentLocation(&typePos) ||
       dispatchParse(parser, elementType) || parser.parseGreater())
     return Type();
 
   // We parsed a generic dimension list, but vectors only support two forms:
   //  - single non-dynamic entry in the list (fixed vector);
static Type parseVectorType(AsmParser &parser) {
   }
   return parser.getChecked<LLVMFixedVectorType>(loc, elementType, dims[0]);
 }
 
 /// Parses an LLVM dialect array type.
 ///   llvm-type ::= `array<` integer `x` llvm-type `>`
 static LLVMArrayType parseArrayType(AsmParser &parser) {
   SmallVector<int64_t, 1> dims;
-  llvm::SMLoc sizePos;
+  SMLoc sizePos;
   Type elementType;
-  llvm::SMLoc loc = parser.getCurrentLocation();
+  SMLoc loc = parser.getCurrentLocation();
   if (parser.parseLess() || parser.getCurrentLocation(&sizePos) ||
       parser.parseDimensionList(dims, /*allowDynamic=*/false) ||
       dispatchParse(parser, elementType) || parser.parseGreater())
     return LLVMArrayType();
 
   if (dims.size() != 1) {
     parser.emitError(sizePos) << "expected ? x <type>";
     return LLVMArrayType();
   }
 
   return parser.getChecked<LLVMArrayType>(loc, elementType, dims[0]);
 }
 
 /// Attempts to set the body of an identified structure type. Reports a parsing
 /// error at `subtypesLoc` in case of failure.
 static LLVMStructType trySetStructBody(LLVMStructType type,
                                        ArrayRef<Type> subtypes, bool isPacked,
                                        AsmParser &parser,
-                                       llvm::SMLoc subtypesLoc) {
+                                       SMLoc subtypesLoc) {
   for (Type t : subtypes) {
     if (!LLVMStructType::isValidElementType(t)) {
       parser.emitError(subtypesLoc)
           << "invalid LLVM structure element type: " << t;
       return LLVMStructType();
     }
   }
 
if (knownStructNames.count(name)) {
       return LLVMStructType::getIdentifiedChecked(
           [loc] { return emitError(loc); }, loc.getContext(), name);
     }
     if (failed(parser.parseComma()))
       return LLVMStructType();
   }
 
   // Handle intentionally opaque structs.
-  llvm::SMLoc kwLoc = parser.getCurrentLocation();
+  SMLoc kwLoc = parser.getCurrentLocation();
   if (succeeded(parser.parseOptionalKeyword("opaque"))) {
     if (!isIdentified)
       return parser.emitError(kwLoc, "only identified structs can be opaque"),
              LLVMStructType();
     if (failed(parser.parseGreater()))
       return LLVMStructType();
     auto type = LLVMStructType::getOpaqueChecked(
         [loc] { return emitError(loc); }, loc.getContext(), name);
if (succeeded(parser.parseOptionalRParen())) {
     auto type = LLVMStructType::getIdentifiedChecked(
         [loc] { return emitError(loc); }, loc.getContext(), name);
     return trySetStructBody(type, {}, isPacked, parser, kwLoc);
   }
 
   // Parse subtypes. For identified structs, put the identifier of the struct on
   // the stack to support self-references in the recursive calls.
   SmallVector<Type, 4> subtypes;
-  llvm::SMLoc subtypesLoc = parser.getCurrentLocation();
+  SMLoc subtypesLoc = parser.getCurrentLocation();
   do {
     if (isIdentified)
       knownStructNames.insert(name);
     Type type;
     if (dispatchParse(parser, type))
       return LLVMStructType();
     subtypes.push_back(type);
     if (isIdentified)
static LLVMStructType parseStructType(AsmParser &parser) {
   return trySetStructBody(type, subtypes, isPacked, parser, subtypesLoc);
 }
 
 /// Parses a type appearing inside another LLVM dialect-compatible type. This
 /// will try to parse any type in full form (including types with the `!llvm`
 /// prefix), and on failure fall back to parsing the short-hand version of the
 /// LLVM dialect types without the `!llvm` prefix.
 static Type dispatchParse(AsmParser &parser, bool allowAny = true) {
-  llvm::SMLoc keyLoc = parser.getCurrentLocation();
+  SMLoc keyLoc = parser.getCurrentLocation();
 
   // Try parsing any MLIR type.
   Type type;
   OptionalParseResult result = parser.parseOptionalType(type);
   if (result.hasValue()) {
     if (failed(result.getValue()))
       return nullptr;
     if (!allowAny) {

 /// Helper to use in parse lists.
 static ParseResult dispatchParse(AsmParser &parser, Type &type) {
   type = dispatchParse(parser);
   return success(type != nullptr);
 }
 
 /// Parses one of the LLVM dialect types.
 Type mlir::LLVM::detail::parseType(DialectAsmParser &parser) {
-  llvm::SMLoc loc = parser.getCurrentLocation();
+  SMLoc loc = parser.getCurrentLocation();
   Type type = dispatchParse(parser, /*allowAny=*/false);
   if (!type)
     return type;
   if (!isCompatibleOuterType(type)) {
     parser.emitError(loc) << "unexpected type, expected keyword";
     return nullptr;
   }
   return type;
 }

mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp

static void print(OpAsmPrinter &p, linalg::YieldOp op) {
   p.printOptionalAttrDict(op->getAttrs());
   if (op.getNumOperands() > 0)
     p << " : " << op.getOperandTypes();
 }
 
 static ParseResult parseYieldOp(OpAsmParser &parser, OperationState &result) {
   SmallVector<OpAsmParser::OperandType, 2> opInfo;
   SmallVector<Type, 2> types;
-  llvm::SMLoc loc = parser.getCurrentLocation();
+  SMLoc loc = parser.getCurrentLocation();
   return failure(parser.parseOperandList(opInfo) ||
                  parser.parseOptionalAttrDict(result.attributes) ||
                  (!opInfo.empty() && parser.parseColonTypeList(types)) ||
                  parser.resolveOperands(opInfo, types, loc, result.operands));
 }
 
 // Check the operand number and types must match the element types of the
 // LinalgOp interface's shaped operands.
if (parser.parseKeyword("step") ||
                               OpAsmParser::Delimiter::Paren) ||
       parser.resolveOperands(steps, builder.getIndexType(), result.operands))
     return failure();
 
   // Parse input tensors.
   SmallVector<OpAsmParser::OperandType, 4> inputs, inputRegionArgs;
   SmallVector<Type, 4> inputTypes;
   if (succeeded(parser.parseOptionalKeyword("ins"))) {
-    llvm::SMLoc inputsOperandsLoc = parser.getCurrentLocation();
+    SMLoc inputsOperandsLoc = parser.getCurrentLocation();
 
     if (parser.parseAssignmentListWithTypes(inputRegionArgs, inputs,
                                             inputTypes))
       return failure();
 
     if (parser.resolveOperands(inputs, inputTypes, inputsOperandsLoc,
                                result.operands))
       return failure();
   }
 
   // Parse output tensors.
   SmallVector<OpAsmParser::OperandType, 4> outputs, outputRegionArgs;
   SmallVector<Type, 4> outputTypes;
   if (succeeded(parser.parseOptionalKeyword("outs"))) {
-    llvm::SMLoc outputsOperandsLoc = parser.getCurrentLocation();
+    SMLoc outputsOperandsLoc = parser.getCurrentLocation();
 
     if (parser.parseAssignmentListWithTypes(outputRegionArgs, outputs,
                                             outputTypes))
       return failure();
 
     if (parser.resolveOperands(outputs, outputTypes, outputsOperandsLoc,
                                result.operands))
       return failure();

 }
 
 /// Common parsing used for both named structured ops created by ods-gen and by
 /// manually defined C++ ops. Does not handle regions.
 static ParseResult
 parseCommonStructuredOpParts(OpAsmParser &parser, OperationState &result,
                              SmallVectorImpl<Type> &inputTypes,
                              SmallVectorImpl<Type> &outputTypes) {
-  llvm::SMLoc inputsOperandsLoc, outputsOperandsLoc;
+  SMLoc inputsOperandsLoc, outputsOperandsLoc;
   SmallVector<OpAsmParser::OperandType, 4> inputsOperands, outputsOperands;
 
   parser.parseOptionalAttrDict(result.attributes);
 
   if (succeeded(parser.parseOptionalKeyword("ins"))) {
     if (parser.parseLParen())
       return failure();
 

mlir/lib/Dialect/MemRef/IR/MemRefOps.cpp

 //===----------------------------------------------------------------------===//
 
 static ParseResult parseViewOp(OpAsmParser &parser, OperationState &result) {
   OpAsmParser::OperandType srcInfo;
   SmallVector<OpAsmParser::OperandType, 1> offsetInfo;
   SmallVector<OpAsmParser::OperandType, 4> sizesInfo;
   auto indexType = parser.getBuilder().getIndexType();
   Type srcType, dstType;
-  llvm::SMLoc offsetLoc;
+  SMLoc offsetLoc;
   if (parser.parseOperand(srcInfo) || parser.getCurrentLocation(&offsetLoc) ||
       parser.parseOperandList(offsetInfo, OpAsmParser::Delimiter::Square))
     return failure();
 
   if (offsetInfo.size() != 1)
     return parser.emitError(offsetLoc) << "expects 1 offset operand";
 
   return failure(

mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp

 //===----------------------------------------------------------------------===//
 
 /// Parse a clause attribute `(` $value `)`.
 template <typename ClauseAttr>
 static ParseResult parseClauseAttr(AsmParser &parser, OperationState &state,
                                    StringRef attrName, StringRef name) {
   using ClauseT = decltype(std::declval<ClauseAttr>().getValue());
   StringRef enumStr;
-  llvm::SMLoc loc = parser.getCurrentLocation();
+  SMLoc loc = parser.getCurrentLocation();
   if (parser.parseLParen() || parser.parseKeyword(&enumStr) ||
       parser.parseRParen())
     return failure();
   if (Optional<ClauseT> enumValue = symbolizeEnum<ClauseT>(enumStr)) {
     auto attr = ClauseAttr::get(parser.getContext(), *enumValue);
     state.addAttribute(attrName, attr);
     return success();
   }
if (clauseKeyword == "if") {
       if (checkAllowed(allocateClause) ||
           parseAllocateAndAllocator(parser, allocates, allocateTypes,
                                     allocators, allocatorTypes))
         return failure();
       clauseSegments[pos[allocateClause]] = allocates.size();
       clauseSegments[pos[allocateClause] + 1] = allocators.size();
     } else if (clauseKeyword == "default") {
       StringRef defval;
-      llvm::SMLoc loc = parser.getCurrentLocation();
+      SMLoc loc = parser.getCurrentLocation();
       if (checkAllowed(defaultClause) || parser.parseLParen() ||
           parser.parseKeyword(&defval) || parser.parseRParen())
         return failure();
       // The def prefix is required for the attribute as "private" is a keyword
       // in C++.
       if (Optional<ClauseDefault> def =
               symbolizeClauseDefault(("def" + defval).str())) {
         result.addAttribute("default_val",
if (Optional<ClauseScheduleKind> sched =
             symbolizeClauseScheduleKind(schedule)) {
       auto attr = ClauseScheduleKindAttr::get(parser.getContext(), *sched);
       result.addAttribute("schedule_val", attr);
     } else {
       return parser.emitError(parser.getCurrentLocation(),
                               "invalid schedule kind");
     }
     if (!modifiers.empty()) {
-      llvm::SMLoc loc = parser.getCurrentLocation();
+      SMLoc loc = parser.getCurrentLocation();
       if (Optional<ScheduleModifier> mod =
               symbolizeScheduleModifier(modifiers[0])) {
         result.addAttribute(
             "schedule_modifier",
             ScheduleModifierAttr::get(parser.getContext(), *mod));
       } else {
         return parser.emitError(loc, "invalid schedule modifier");
       }

mlir/lib/Dialect/PDL/IR/PDLTypes.cpp

 //===----------------------------------------------------------------------===//
 // RangeType
 //===----------------------------------------------------------------------===//
 
 Type RangeType::parse(AsmParser &parser) {
   if (parser.parseLess())
     return Type();
 
-  llvm::SMLoc elementLoc = parser.getCurrentLocation();
+  SMLoc elementLoc = parser.getCurrentLocation();
   Type elementType = parsePDLType(parser);
   if (!elementType || parser.parseGreater())
     return Type();
 
   if (elementType.isa<RangeType>()) {
     parser.emitError(elementLoc)
         << "element of pdl.range cannot be another range, but got"
         << elementType;

mlir/lib/Dialect/Quant/IR/TypeParser.cpp

int64_t defaultIntegerMax = QuantizedType::getDefaultMaximumForInteger(
       isSigned, storageType.getWidth());
   if (failed(parser.parseOptionalLess())) {
     storageTypeMin = defaultIntegerMin;
     storageTypeMax = defaultIntegerMax;
     return success();
   }
 
   // Explicit storage min and storage max.
-  llvm::SMLoc minLoc = parser.getCurrentLocation(), maxLoc;
+  SMLoc minLoc = parser.getCurrentLocation(), maxLoc;
   if (parser.parseInteger(storageTypeMin) || parser.parseColon() ||
       parser.getCurrentLocation(&maxLoc) ||
       parser.parseInteger(storageTypeMax) || parser.parseGreater())
     return failure();
   if (storageTypeMin < defaultIntegerMin) {
     return parser.emitError(minLoc, "illegal storage type minimum: ")
            << storageTypeMin;
   }
static Type parseUniformType(DialectAsmParser &parser) {
   // For per-axis, ranges are in a {} delimitted list.
   if (isPerAxis) {
     if (parser.parseLBrace()) {
       return nullptr;
     }
   }
 
   // Parse scales/zeroPoints.
-  llvm::SMLoc scaleZPLoc = parser.getCurrentLocation();
+  SMLoc scaleZPLoc = parser.getCurrentLocation();
   do {
     scales.resize(scales.size() + 1);
     zeroPoints.resize(zeroPoints.size() + 1);
     if (parseQuantParams(parser, scales.back(), zeroPoints.back())) {
       return nullptr;
     }
   } while (isPerAxis && succeeded(parser.parseOptionalComma()));
 

mlir/lib/Dialect/SCF/SCF.cpp

static ParseResult parseWhileOp(OpAsmParser &parser, OperationState &result) {
   Region *after = result.addRegion();
 
   OptionalParseResult listResult =
       parser.parseOptionalAssignmentList(regionArgs, operands);
   if (listResult.hasValue() && failed(listResult.getValue()))
     return failure();
 
   FunctionType functionType;
-  llvm::SMLoc typeLoc = parser.getCurrentLocation();
+  SMLoc typeLoc = parser.getCurrentLocation();
   if (failed(parser.parseColonType(functionType)))
     return failure();
 
   result.addTypes(functionType.getResults());
 
   if (functionType.getNumInputs() != operands.size()) {
     return parser.emitError(typeLoc)
            << "expected as many input types as operands "

mlir/lib/Dialect/SPIRV/IR/SPIRVDialect.cpp

 
 template <>
 Optional<unsigned> parseAndVerify<unsigned>(SPIRVDialect const &dialect,
                                             DialectAsmParser &parser);
 
 static Type parseAndVerifyType(SPIRVDialect const &dialect,
                                DialectAsmParser &parser) {
   Type type;
-  llvm::SMLoc typeLoc = parser.getCurrentLocation();
+  SMLoc typeLoc = parser.getCurrentLocation();
   if (parser.parseType(type))
     return Type();
 
   // Allow SPIR-V dialect types
   if (&type.getDialect() == &dialect)
     return type;
 
   // Check other allowed types
static Type parseAndVerifyType(SPIRVDialect const &dialect,
   }
 
   return type;
 }
 
 static Type parseAndVerifyMatrixType(SPIRVDialect const &dialect,
                                      DialectAsmParser &parser) {
   Type type;
-  llvm::SMLoc typeLoc = parser.getCurrentLocation();
+  SMLoc typeLoc = parser.getCurrentLocation();
   if (parser.parseType(type))
     return Type();
 
   if (auto t = type.dyn_cast<VectorType>()) {
     if (t.getRank() != 1) {
       parser.emitError(typeLoc, "only 1-D vector allowed but found ") << t;
       return Type();
     }
static Type parseAndVerifyMatrixType(SPIRVDialect const &dialect,
   }
 
   return type;
 }
 
 static Type parseAndVerifySampledImageType(SPIRVDialect const &dialect,
                                            DialectAsmParser &parser) {
   Type type;
-  llvm::SMLoc typeLoc = parser.getCurrentLocation();
+  SMLoc typeLoc = parser.getCurrentLocation();
   if (parser.parseType(type))
     return Type();
 
   if (!type.isa<ImageType>()) {
     parser.emitError(typeLoc,
                      "sampled image must be composed using image type, got ")
         << type;
     return Type();
static LogicalResult parseOptionalArrayStride(const SPIRVDialect &dialect,
   if (failed(parser.parseOptionalComma())) {
     stride = 0;
     return success();
   }
 
   if (parser.parseKeyword("stride") || parser.parseEqual())
     return failure();
 
-  llvm::SMLoc strideLoc = parser.getCurrentLocation();
+  SMLoc strideLoc = parser.getCurrentLocation();
   Optional<unsigned> optStride = parseAndVerify<unsigned>(dialect, parser);
   if (!optStride)
     return failure();
 
   if (!(stride = optStride.getValue())) {
     parser.emitError(strideLoc, "ArrayStride must be greater than zero");
     return failure();
   }
   return success();
 }
 
 // element-type ::= integer-type
 //                | floating-point-type
 //                | vector-type
 //                | spirv-type
 //
 // array-type ::= `!spv.array` `<` integer-literal `x` element-type
 //                (`,` `stride` `=` integer-literal)? `>`
 static Type parseArrayType(SPIRVDialect const &dialect,
                            DialectAsmParser &parser) {
   if (parser.parseLess())
     return Type();
 
   SmallVector<int64_t, 1> countDims;
-  llvm::SMLoc countLoc = parser.getCurrentLocation();
+  SMLoc countLoc = parser.getCurrentLocation();
   if (parser.parseDimensionList(countDims, /*allowDynamic=*/false))
     return Type();
   if (countDims.size() != 1) {
     parser.emitError(countLoc,
                      "expected single integer for array element count");
     return Type();
   }
 

 // cooperative-matrix-type ::= `!spv.coopmatrix` `<` element-type ',' scope ','
 //                                                   rows ',' columns>`
 static Type parseCooperativeMatrixType(SPIRVDialect const &dialect,
                                        DialectAsmParser &parser) {
   if (parser.parseLess())
     return Type();
 
   SmallVector<int64_t, 2> dims;
-  llvm::SMLoc countLoc = parser.getCurrentLocation();
+  SMLoc countLoc = parser.getCurrentLocation();
   if (parser.parseDimensionList(dims, /*allowDynamic=*/false))
     return Type();
 
   if (dims.size() != 2) {
     parser.emitError(countLoc, "expected rows and columns size");
     return Type();
   }
 
static Type parsePointerType(SPIRVDialect const &dialect,
   if (parser.parseLess())
     return Type();
 
   auto pointeeType = parseAndVerifyType(dialect, parser);
   if (!pointeeType)
     return Type();
 
   StringRef storageClassSpec;
-  llvm::SMLoc storageClassLoc = parser.getCurrentLocation();
+  SMLoc storageClassLoc = parser.getCurrentLocation();
   if (parser.parseComma() || parser.parseKeyword(&storageClassSpec))
     return Type();
 
   auto storageClass = symbolizeStorageClass(storageClassSpec);
   if (!storageClass) {
     parser.emitError(storageClassLoc, "unknown storage class: ")
         << storageClassSpec;
     return Type();

 
 // matrix-type ::= `!spv.matrix` `<` integer-literal `x` element-type `>`
 static Type parseMatrixType(SPIRVDialect const &dialect,
                             DialectAsmParser &parser) {
   if (parser.parseLess())
     return Type();
 
   SmallVector<int64_t, 1> countDims;
-  llvm::SMLoc countLoc = parser.getCurrentLocation();
+  SMLoc countLoc = parser.getCurrentLocation();
   if (parser.parseDimensionList(countDims, /*allowDynamic=*/false))
     return Type();
   if (countDims.size() != 1) {
     parser.emitError(countLoc, "expected single unsigned "
                                "integer for number of columns");
     return Type();
   }
 

 }
 
 // Specialize this function to parse each of the parameters that define an
 // ImageType. By default it assumes this is an enum type.
 template <typename ValTy>
 static Optional<ValTy> parseAndVerify(SPIRVDialect const &dialect,
                                       DialectAsmParser &parser) {
   StringRef enumSpec;
-  llvm::SMLoc enumLoc = parser.getCurrentLocation();
+  SMLoc enumLoc = parser.getCurrentLocation();
   if (parser.parseKeyword(&enumSpec)) {
     return llvm::None;
   }
 
   auto val = spirv::symbolizeEnum<ValTy>(enumSpec);
   if (!val)
     parser.emitError(enumLoc, "unknown attribute: '") << enumSpec << "'";
   return val;

 // Parse decorations associated with a member.
 static ParseResult parseStructMemberDecorations(
     SPIRVDialect const &dialect, DialectAsmParser &parser,
     ArrayRef<Type> memberTypes,
     SmallVectorImpl<StructType::OffsetInfo> &offsetInfo,
     SmallVectorImpl<StructType::MemberDecorationInfo> &memberDecorationInfo) {
 
   // Check if the first element is offset.
-  llvm::SMLoc offsetLoc = parser.getCurrentLocation();
+  SMLoc offsetLoc = parser.getCurrentLocation();
   StructType::OffsetInfo offset = 0;
   OptionalParseResult offsetParseResult = parser.parseOptionalInteger(offset);
   if (offsetParseResult.hasValue()) {
     if (failed(*offsetParseResult))
       return failure();
 
     if (offsetInfo.size() != memberTypes.size() - 1) {
       return parser.emitError(offsetLoc,

 }
 
 //===----------------------------------------------------------------------===//
 // Attribute Parsing
 //===----------------------------------------------------------------------===//
 
 /// Parses a comma-separated list of keywords, invokes `processKeyword` on each
 /// of the parsed keyword, and returns failure if any error occurs.
 static ParseResult parseKeywordList(
     DialectAsmParser &parser,
-    function_ref<LogicalResult(llvm::SMLoc, StringRef)> processKeyword) {
+    function_ref<LogicalResult(SMLoc, StringRef)> processKeyword) {
   if (parser.parseLSquare())
     return failure();
 
   // Special case for empty list.
   if (succeeded(parser.parseOptionalRSquare()))
     return success();
 
   // Keep parsing the keyword and an optional comma following it. If the comma
if (auto versionSymbol = spirv::symbolizeVersion(version)) {
       parser.emitError(loc, "unknown version: ") << version;
       return {};
     }
   }
 
   ArrayAttr capabilitiesAttr;
   {
     SmallVector<Attribute, 4> capabilities;
-    llvm::SMLoc errorloc;
+    SMLoc errorloc;
     StringRef errorKeyword;
 
-    auto processCapability = [&](llvm::SMLoc loc, StringRef capability) {
+    auto processCapability = [&](SMLoc loc, StringRef capability) {
       if (auto capSymbol = spirv::symbolizeCapability(capability)) {
         capabilities.push_back(
             builder.getI32IntegerAttr(static_cast<uint32_t>(*capSymbol)));
         return success();
       }
       return errorloc = loc, errorKeyword = capability, failure();
     };
     if (parseKeywordList(parser, processCapability) || parser.parseComma()) {
       if (!errorKeyword.empty())
         parser.emitError(errorloc, "unknown capability: ") << errorKeyword;
       return {};
     }
 
     capabilitiesAttr = builder.getArrayAttr(capabilities);
   }
 
   ArrayAttr extensionsAttr;
   {
     SmallVector<Attribute, 1> extensions;
-    llvm::SMLoc errorloc;
+    SMLoc errorloc;
     StringRef errorKeyword;
 
-    auto processExtension = [&](llvm::SMLoc loc, StringRef extension) {
+    auto processExtension = [&](SMLoc loc, StringRef extension) {
       if (spirv::symbolizeExtension(extension)) {
         extensions.push_back(builder.getStringAttr(extension));
         return success();
       }
       return errorloc = loc, errorKeyword = extension, failure();
     };
     if (parseKeywordList(parser, processExtension)) {
       if (!errorKeyword.empty())

mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp

 static Type getElementType(Type type, Attribute indices, Location loc) {
   auto errorFn = [&](StringRef err) -> InFlightDiagnostic {
     return ::mlir::emitError(loc, err);
   };
   return getElementType(type, indices, errorFn);
 }
 
 static Type getElementType(Type type, Attribute indices, OpAsmParser &parser,
-                           llvm::SMLoc loc) {
+                           SMLoc loc) {
   auto errorFn = [&](StringRef err) -> InFlightDiagnostic {
     return parser.emitError(loc, err);
   };
   return getElementType(type, indices, errorFn);
 }
 
 /// Returns true if the given `block` only contains one `spv.mlir.merge` op.
 static inline bool isMergeBlock(Block &block) {

 // AtomicIIncrement) `hasValue` must be false.
 static ParseResult parseAtomicUpdateOp(OpAsmParser &parser,
                                        OperationState &state, bool hasValue) {
   spirv::Scope scope;
   spirv::MemorySemantics memoryScope;
   SmallVector<OpAsmParser::OperandType, 2> operandInfo;
   OpAsmParser::OperandType ptrInfo, valueInfo;
   Type type;
-  llvm::SMLoc loc;
+  SMLoc loc;
   if (parseEnumStrAttr(scope, parser, state, kMemoryScopeAttrName) ||
       parseEnumStrAttr(memoryScope, parser, state, kSemanticsAttrName) ||
       parser.parseOperandList(operandInfo, (hasValue ? 2 : 1)) ||
       parser.getCurrentLocation(&loc) || parser.parseColonType(type))
     return failure();
 
   auto ptrType = type.dyn_cast<spirv::PointerType>();
   if (!ptrType)
void spirv::CompositeExtractOp::build(OpBuilder &builder, OperationState &state,
   build(builder, state, elementType, composite, indexAttr);
 }
 
 static ParseResult parseCompositeExtractOp(OpAsmParser &parser,
                                            OperationState &state) {
   OpAsmParser::OperandType compositeInfo;
   Attribute indicesAttr;
   Type compositeType;
-  llvm::SMLoc attrLocation;
+  SMLoc attrLocation;
 
   if (parser.parseOperand(compositeInfo) ||
       parser.getCurrentLocation(&attrLocation) ||
       parser.parseAttribute(indicesAttr, kIndicesAttrName, state.attributes) ||
       parser.parseColonType(compositeType) ||
       parser.resolveOperand(compositeInfo, compositeType, state.operands)) {
     return failure();
   }

mlir/lib/Dialect/Vector/VectorOps.cpp

 
 static void print(OpAsmPrinter &p, vector::ExtractOp op) {
   p << " " << op.vector() << op.position();
   p.printOptionalAttrDict(op->getAttrs(), {"position"});
   p << " : " << op.vector().getType();
 }
 
 static ParseResult parseExtractOp(OpAsmParser &parser, OperationState &result) {
-  llvm::SMLoc attributeLoc, typeLoc;
+  SMLoc attributeLoc, typeLoc;
   NamedAttrList attrs;
   OpAsmParser::OperandType vector;
   Type type;
   Attribute attr;
   if (parser.parseOperand(vector) || parser.getCurrentLocation(&attributeLoc) ||
       parser.parseAttribute(attr, "position", attrs) ||
       parser.parseOptionalAttrDict(attrs) ||
       parser.getCurrentLocation(&typeLoc) || parser.parseColonType(type))
if (op.mask())
     p << ", " << op.mask();
   printTransferAttrs(p, cast<VectorTransferOpInterface>(op.getOperation()));
   p << " : " << op.getShapedType() << ", " << op.getVectorType();
 }
 
 static ParseResult parseTransferReadOp(OpAsmParser &parser,
                                        OperationState &result) {
   auto &builder = parser.getBuilder();
-  llvm::SMLoc typesLoc;
+  SMLoc typesLoc;
   OpAsmParser::OperandType sourceInfo;
   SmallVector<OpAsmParser::OperandType, 8> indexInfo;
   OpAsmParser::OperandType paddingInfo;
   SmallVector<Type, 2> types;
   OpAsmParser::OperandType maskInfo;
   // Parsing with support for paddingValue.
   if (parser.parseOperand(sourceInfo) ||
       parser.parseOperandList(indexInfo, OpAsmParser::Delimiter::Square) ||
void TransferWriteOp::build(OpBuilder &builder, OperationState &result,
   AffineMap permutationMap = getTransferMinorIdentityMap(
       dest.getType().cast<ShapedType>(), vectorType);
   build(builder, result, vector, dest, indices, permutationMap, inBounds);
 }
 
 static ParseResult parseTransferWriteOp(OpAsmParser &parser,
                                         OperationState &result) {
   auto &builder = parser.getBuilder();
-  llvm::SMLoc typesLoc;
+  SMLoc typesLoc;
   OpAsmParser::OperandType vectorInfo, sourceInfo;
   SmallVector<OpAsmParser::OperandType, 8> indexInfo;
   SmallVector<Type, 2> types;
   OpAsmParser::OperandType maskInfo;
   if (parser.parseOperand(vectorInfo) || parser.parseComma() ||
       parser.parseOperand(sourceInfo) ||
       parser.parseOperandList(indexInfo, OpAsmParser::Delimiter::Square))
     return failure();

mlir/lib/ExecutionEngine/JitRunner.cpp

static OwningModuleRef parseMLIRInput(StringRef inputFilename,
   std::string errorMessage;
   auto file = openInputFile(inputFilename, &errorMessage);
   if (!file) {
     llvm::errs() << errorMessage << "\n";
     return nullptr;
   }
 
   llvm::SourceMgr sourceMgr;
-  sourceMgr.AddNewSourceBuffer(std::move(file), llvm::SMLoc());
+  sourceMgr.AddNewSourceBuffer(std::move(file), SMLoc());
   return OwningModuleRef(parseSourceFile(sourceMgr, context));
 }
 
 static inline Error makeStringError(const Twine &message) {
   return llvm::make_error<llvm::StringError>(message.str(),
                                              llvm::inconvertibleErrorCode());
 }
 

mlir/lib/IR/Diagnostics.cpp

unsigned getSourceMgrBufferIDForFile(llvm::SourceMgr &mgr,
     for (unsigned i = 1, e = mgr.getNumBuffers() + 1; i != e; ++i) {
       auto *buf = mgr.getMemoryBuffer(i);
       if (buf->getBufferIdentifier() == filename)
         return filenameToBufId[filename] = i;
     }
 
     // Otherwise, try to load the source file.
     std::string ignored;
     unsigned id =
-        mgr.AddIncludeFile(std::string(filename), llvm::SMLoc(), ignored);
+        mgr.AddIncludeFile(std::string(filename), SMLoc(), ignored);
     filenameToBufId[filename] = id;
     return id;
   }
 
   /// Mapping between file name and buffer ID's.
   llvm::StringMap<unsigned> filenameToBufId;
 };
 } // namespace detail
void SourceMgrDiagnosticHandler::emitDiagnostic(Location loc, Twine message,
 
   // If one doesn't exist, then print the raw message without a source location.
   if (!fileLoc) {
     std::string str;
     llvm::raw_string_ostream strOS(str);
     if (!loc.isa<UnknownLoc>())
       strOS << loc << ": ";
     strOS << message;
-    return mgr.PrintMessage(os, llvm::SMLoc(), getDiagKind(kind), strOS.str());
+    return mgr.PrintMessage(os, SMLoc(), getDiagKind(kind), strOS.str());
   }
 
   // Otherwise if we are displaying the source line, try to convert the file
   // location to an SMLoc.
   if (displaySourceLine) {
     auto smloc = convertLocToSMLoc(*fileLoc);
     if (smloc.isValid())
       return mgr.PrintMessage(os, smloc, getDiagKind(kind), message);
return TypeSwitch<LocationAttr, Optional<Location>>(loc)
       .Case([](UnknownLoc) -> Optional<Location> {
         // Prefer not to show unknown locations.
         return llvm::None;
       });
 }
 
 /// Get a memory buffer for the given file, or the main file of the source
 /// manager if one doesn't exist. This always returns non-null.
-llvm::SMLoc SourceMgrDiagnosticHandler::convertLocToSMLoc(FileLineColLoc loc) {
+SMLoc SourceMgrDiagnosticHandler::convertLocToSMLoc(FileLineColLoc loc) {
   // The column and line may be zero to represent unknown column and/or unknown
   /// line/column information.
   if (loc.getLine() == 0 || loc.getColumn() == 0)
-    return llvm::SMLoc();
+    return SMLoc();
 
   unsigned bufferId = impl->getSourceMgrBufferIDForFile(mgr, loc.getFilename());
   if (!bufferId)
-    return llvm::SMLoc();
+    return SMLoc();
   return mgr.FindLocForLineAndColumn(bufferId, loc.getLine(), loc.getColumn());
 }
 
 //===----------------------------------------------------------------------===//
 // SourceMgrDiagnosticVerifierHandler
 //===----------------------------------------------------------------------===//
 
 namespace mlir {
 namespace detail {
 // Record the expected diagnostic's position, substring and whether it was
 // seen.
 struct ExpectedDiag {
   DiagnosticSeverity kind;
   unsigned lineNo;
   StringRef substring;
-  llvm::SMLoc fileLoc;
+  SMLoc fileLoc;
   bool matched;
 };
 
 struct SourceMgrDiagnosticVerifierHandlerImpl {
   SourceMgrDiagnosticVerifierHandlerImpl() : status(success()) {}
 
   /// Returns the expected diagnostics for the given source file.
   Optional<MutableArrayRef<ExpectedDiag>> getExpectedDiags(StringRef bufName);
if (!expected.match(lines[lineNo], &matches)) {
           expectedDiags[diagIndex].lineNo = lineNo + 1;
         designatorsForNextLine.clear();
       }
       lastNonDesignatorLine = lineNo;
       continue;
     }
 
     // Point to the start of expected-*.
-    auto expectedStart = llvm::SMLoc::getFromPointer(matches[0].data());
+    auto expectedStart = SMLoc::getFromPointer(matches[0].data());
 
     DiagnosticSeverity kind;
     if (matches[1] == "error")
       kind = DiagnosticSeverity::Error;
     else if (matches[1] == "warning")
       kind = DiagnosticSeverity::Warning;
     else if (matches[1] == "remark")
       kind = DiagnosticSeverity::Remark;

 /// diagnostics were emitted. This return success if all diagnostics were
 /// verified correctly, failure otherwise.
 LogicalResult SourceMgrDiagnosticVerifierHandler::verify() {
   // Verify that all expected errors were seen.
   for (auto &expectedDiagsPair : impl->expectedDiagsPerFile) {
     for (auto &err : expectedDiagsPair.second) {
       if (err.matched)
         continue;
-      llvm::SMRange range(err.fileLoc,
-                          llvm::SMLoc::getFromPointer(err.fileLoc.getPointer() +
+      SMRange range(err.fileLoc,
+                          SMLoc::getFromPointer(err.fileLoc.getPointer() +
                                                       err.substring.size()));
       mgr.PrintMessage(os, err.fileLoc, llvm::SourceMgr::DK_Error,
                        "expected " + getDiagKindStr(err.kind) + " \"" +
                            err.substring + "\" was not produced",
                        range);
       impl->status = failure();
     }
   }

mlir/lib/IR/FunctionImplementation.cpp

ParseResult mlir::function_interface_impl::parseFunctionArgumentList(
     SmallVectorImpl<Location> &argLocations, bool &isVariadic) {
   if (parser.parseLParen())
     return failure();
 
   // The argument list either has to consistently have ssa-id's followed by
   // types, or just be a type list.  It isn't ok to sometimes have SSA ID's and
   // sometimes not.
   auto parseArgument = [&]() -> ParseResult {
-    llvm::SMLoc loc = parser.getCurrentLocation();
+    SMLoc loc = parser.getCurrentLocation();
 
     // Parse argument name if present.
     OpAsmParser::OperandType argument;
     Type argumentType;
     if (succeeded(parser.parseOptionalRegionArgument(argument)) &&
         !argument.name.empty()) {
       // Reject this if the preceding argument was missing a name.
       if (argNames.empty() && !argTypes.empty())
ParseResult mlir::function_interface_impl::parseFunctionArgumentList(
   // Parse the function arguments.
   isVariadic = false;
   if (failed(parser.parseOptionalRParen())) {
     do {
       unsigned numTypedArguments = argTypes.size();
       if (parseArgument())
         return failure();
 
-      llvm::SMLoc loc = parser.getCurrentLocation();
+      SMLoc loc = parser.getCurrentLocation();
       if (argTypes.size() == numTypedArguments &&
           succeeded(parser.parseOptionalComma()))
         return parser.emitError(
             loc, "variadic arguments must be in the end of the argument list");
     } while (succeeded(parser.parseOptionalComma()));
     parser.parseRParen();
   }
 
ParseResult mlir::function_interface_impl::parseFunctionOp(
 
   // Parse the name as a symbol.
   StringAttr nameAttr;
   if (parser.parseSymbolName(nameAttr, SymbolTable::getSymbolAttrName(),
                              result.attributes))
     return failure();
 
   // Parse the function signature.
-  llvm::SMLoc signatureLocation = parser.getCurrentLocation();
+  SMLoc signatureLocation = parser.getCurrentLocation();
   bool isVariadic = false;
   if (parseFunctionSignature(parser, allowVariadic, entryArgs, argTypes,
                              argAttrs, argLocations, isVariadic, resultTypes,
                              resultAttrs))
     return failure();
 
   std::string errorMessage;
   Type type = funcTypeBuilder(builder, argTypes, resultTypes,
                               VariadicFlag(isVariadic), errorMessage);
   if (!type) {
     return parser.emitError(signatureLocation)
            << "failed to construct function type"
            << (errorMessage.empty() ? "" : ": ") << errorMessage;
   }
   result.addAttribute(getTypeAttrName(), TypeAttr::get(type));
 
   // If function attributes are present, parse them.
   NamedAttrList parsedAttributes;
-  llvm::SMLoc attributeDictLocation = parser.getCurrentLocation();
+  SMLoc attributeDictLocation = parser.getCurrentLocation();
   if (parser.parseOptionalAttrDictWithKeyword(parsedAttributes))
     return failure();
 
   // Disallow attributes that are inferred from elsewhere in the attribute
   // dictionary.
   for (StringRef disallowed :
        {SymbolTable::getVisibilityAttrName(), SymbolTable::getSymbolAttrName(),
         getTypeAttrName()}) {
     if (parsedAttributes.get(disallowed))
       return parser.emitError(attributeDictLocation, "'")
              << disallowed
              << "' is an inferred attribute and should not be specified in the "
                 "explicit attribute dictionary";
   }
   result.attributes.append(parsedAttributes);
 
   // Add the attributes to the function arguments.
   assert(argAttrs.size() == argTypes.size());
   assert(resultAttrs.size() == resultTypes.size());
   addArgAndResultAttrs(builder, result, argAttrs, resultAttrs);
 
   // Parse the optional function body. The printer will not print the body if
   // its empty, so disallow parsing of empty body in the parser.
   auto *body = result.addRegion();
-  llvm::SMLoc loc = parser.getCurrentLocation();
+  SMLoc loc = parser.getCurrentLocation();
   OptionalParseResult parseResult = parser.parseOptionalRegion(
       *body, entryArgs, entryArgs.empty() ? ArrayRef<Type>() : argTypes,
       entryArgs.empty() ? ArrayRef<Location>() : argLocations,
       /*enableNameShadowing=*/false);
   if (parseResult.hasValue()) {
     if (failed(*parseResult))
       return failure();
     // Function body was parsed, make sure its not empty.

mlir/lib/IR/Operation.cpp

 }
 
 ParseResult impl::parseOneResultSameOperandTypeOp(OpAsmParser &parser,
                                                   OperationState &result) {
   SmallVector<OpAsmParser::OperandType, 2> ops;
   Type type;
   // If the operand list is in-between parentheses, then we have a generic form.
   // (see the fallback in `printOneResultOp`).
-  llvm::SMLoc loc = parser.getCurrentLocation();
+  SMLoc loc = parser.getCurrentLocation();
   if (!parser.parseOptionalLParen()) {
     if (parser.parseOperandList(ops) || parser.parseRParen() ||
         parser.parseOptionalAttrDict(result.attributes) ||
         parser.parseColon() || parser.parseType(type))
       return failure();
     auto fnType = type.dyn_cast<FunctionType>();
     if (!fnType) {
       parser.emitError(loc, "expected function type");

mlir/lib/Parser/AffineParser.cpp

 
 #include "Parser.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/IntegerSet.h"
 #include "llvm/Support/SourceMgr.h"
 
 using namespace mlir;
 using namespace mlir::detail;
-using llvm::SMLoc;
 
 namespace {
 
 /// Lower precedence ops (all at the same precedence level). LNoOp is false in
 /// the boolean sense.
 enum AffineLowPrecOp {
   /// Null value.
   LNoOp,
private:
   AffineExpr parseParentheticalExpr();
   AffineExpr parseNegateExpression(AffineExpr lhs);
   AffineExpr parseIntegerExpr();
   AffineExpr parseBareIdExpr();
   AffineExpr parseSSAIdExpr(bool isSymbol);
   AffineExpr parseSymbolSSAIdExpr();
 
   AffineExpr getAffineBinaryOpExpr(AffineHighPrecOp op, AffineExpr lhs,
-                                   AffineExpr rhs, llvm::SMLoc opLoc);
+                                   AffineExpr rhs, SMLoc opLoc);
   AffineExpr getAffineBinaryOpExpr(AffineLowPrecOp op, AffineExpr lhs,
                                    AffineExpr rhs);
   AffineExpr parseAffineOperandExpr(AffineExpr lhs);
   AffineExpr parseAffineLowPrecOpExpr(AffineExpr llhs, AffineLowPrecOp llhsOp);
   AffineExpr parseAffineHighPrecOpExpr(AffineExpr llhs, AffineHighPrecOp llhsOp,
-                                       llvm::SMLoc llhsOpLoc);
+                                       SMLoc llhsOpLoc);
   AffineExpr parseAffineConstraint(bool *isEq);
 
 private:
   bool allowParsingSSAIds;
   function_ref<ParseResult(bool)> parseElement;
   unsigned numDimOperands;
   unsigned numSymbolOperands;
   SmallVector<std::pair<StringRef, AffineExpr>, 4> dimsAndSymbols;

 //===----------------------------------------------------------------------===//
 
 /// Parse an ambiguous reference to either and affine map or an integer set.
 ParseResult Parser::parseAffineMapOrIntegerSetReference(AffineMap &map,
                                                         IntegerSet &set) {
   return AffineParser(state).parseAffineMapOrIntegerSetInline(map, set);
 }
 ParseResult Parser::parseAffineMapReference(AffineMap &map) {
-  llvm::SMLoc curLoc = getToken().getLoc();
+  SMLoc curLoc = getToken().getLoc();
   IntegerSet set;
   if (parseAffineMapOrIntegerSetReference(map, set))
     return failure();
   if (set)
     return emitError(curLoc, "expected AffineMap, but got IntegerSet");
   return success();
 }
 ParseResult Parser::parseIntegerSetReference(IntegerSet &set) {
-  llvm::SMLoc curLoc = getToken().getLoc();
+  SMLoc curLoc = getToken().getLoc();
   AffineMap map;
   if (parseAffineMapOrIntegerSetReference(map, set))
     return failure();
   if (map)
     return emitError(curLoc, "expected IntegerSet, but got AffineMap");
   return success();
 }
 

mlir/lib/Parser/AsmParserImpl.h

 // AsmParserImpl
 //===----------------------------------------------------------------------===//
 
 /// This class provides the implementation of the generic parser methods within
 /// AsmParser.
 template <typename BaseT>
 class AsmParserImpl : public BaseT {
 public:
-  AsmParserImpl(llvm::SMLoc nameLoc, Parser &parser)
+  AsmParserImpl(SMLoc nameLoc, Parser &parser)
       : nameLoc(nameLoc), parser(parser) {}
   ~AsmParserImpl() override = default;
 
   /// Return the location of the original name token.
-  llvm::SMLoc getNameLoc() const override { return nameLoc; }
+  SMLoc getNameLoc() const override { return nameLoc; }
 
   //===--------------------------------------------------------------------===//
   // Utilities
   //===--------------------------------------------------------------------===//
 
   /// Return if any errors were emitted during parsing.
   bool didEmitError() const { return emittedError; }
 
   /// Emit a diagnostic at the specified location and return failure.
-  InFlightDiagnostic emitError(llvm::SMLoc loc, const Twine &message) override {
+  InFlightDiagnostic emitError(SMLoc loc, const Twine &message) override {
     emittedError = true;
     return parser.emitError(loc, message);
   }
 
   /// Return a builder which provides useful access to MLIRContext, global
   /// objects like types and attributes.
   Builder &getBuilder() const override { return parser.builder; }
 
   /// Get the location of the next token and store it into the argument.  This
   /// always succeeds.
-  llvm::SMLoc getCurrentLocation() override {
+  SMLoc getCurrentLocation() override {
     return parser.getToken().getLoc();
   }
 
   /// Re-encode the given source location as an MLIR location and return it.
-  Location getEncodedSourceLoc(llvm::SMLoc loc) override {
+  Location getEncodedSourceLoc(SMLoc loc) override {
     return parser.getEncodedSourceLocation(loc);
   }
 
   //===--------------------------------------------------------------------===//
   // Token Parsing
   //===--------------------------------------------------------------------===//
 
   using Delimiter = AsmParser::Delimiter;
ParseResult parseOptionalKeywordOrString(std::string *result) override {
 
     return parseOptionalString(result);
   }
 
   /// Parse a floating point value from the stream.
   ParseResult parseFloat(double &result) override {
     bool isNegative = parser.consumeIf(Token::minus);
     Token curTok = parser.getToken();
-    llvm::SMLoc loc = curTok.getLoc();
+    SMLoc loc = curTok.getLoc();
 
     // Check for a floating point value.
     if (curTok.is(Token::floatliteral)) {
       auto val = curTok.getFloatingPointValue();
       if (!val.hasValue())
         return emitError(loc, "floating point value too large");
       parser.consumeToken(Token::floatliteral);
       result = isNegative ? -*val : *val;
public:
   }
 
   ParseResult parseXInDimensionList() override {
     return parser.parseXInDimensionList();
   }
 
 protected:
   /// The source location of the dialect symbol.
-  llvm::SMLoc nameLoc;
+  SMLoc nameLoc;
 
   /// The main parser.
   Parser &parser;
 
   /// A flag that indicates if any errors were emitted during parsing.
   bool emittedError = false;
 };
 } // namespace detail
 } // namespace mlir
 
 #endif // MLIR_LIB_PARSER_ASMPARSERIMPL_H

mlir/lib/Parser/AsmParserState.cpp

 
 //===----------------------------------------------------------------------===//
 // AsmParserState::Impl
 //===----------------------------------------------------------------------===//
 
 struct AsmParserState::Impl {
   /// A map from a SymbolRefAttr to a range of uses.
   using SymbolUseMap =
-      DenseMap<Attribute, SmallVector<SmallVector<llvm::SMRange>, 0>>;
+      DenseMap<Attribute, SmallVector<SmallVector<SMRange>, 0>>;
 
   struct PartialOpDef {
     explicit PartialOpDef(const OperationName &opName) {
       if (opName.hasTrait<OpTrait::SymbolTable>())
         symbolTable = std::make_unique<SymbolUseMap>();
     }
 
     /// Return if this operation is a symbol table.
struct AsmParserState::Impl {
   DenseMap<Operation *, unsigned> operationToIdx;
 
   /// A mapping from blocks in the input source file to their parser state.
   SmallVector<std::unique_ptr<BlockDefinition>> blocks;
   DenseMap<Block *, unsigned> blocksToIdx;
 
   /// A set of value definitions that are placeholders for forward references.
   /// This map should be empty if the parser finishes successfully.
-  DenseMap<Value, SmallVector<llvm::SMLoc>> placeholderValueUses;
+  DenseMap<Value, SmallVector<SMLoc>> placeholderValueUses;
 
   /// The symbol table operations within the IR.
   SmallVector<std::pair<Operation *, std::unique_ptr<SymbolUseMap>>>
       symbolTableOperations;
 
   /// A stack of partial operation definitions that have been started but not
   /// yet finalized.
   SmallVector<PartialOpDef> partialOperations;
void AsmParserState::Impl::resolveSymbolUses() {
   SmallVector<Operation *> symbolOps;
   for (auto &opAndUseMapIt : symbolTableOperations) {
     for (auto &it : *opAndUseMapIt.second) {
       symbolOps.clear();
       if (failed(symbolTable.lookupSymbolIn(
               opAndUseMapIt.first, it.first.cast<SymbolRefAttr>(), symbolOps)))
         continue;
 
-      for (ArrayRef<llvm::SMRange> useRange : it.second) {
+      for (ArrayRef<SMRange> useRange : it.second) {
         for (const auto &symIt : llvm::zip(symbolOps, useRange)) {
           auto opIt = operationToIdx.find(std::get<0>(symIt));
           if (opIt != operationToIdx.end())
             operations[opIt->second]->symbolUses.push_back(std::get<1>(symIt));
         }
       }
     }
   }

 
 auto AsmParserState::getOpDef(Operation *op) const
     -> const OperationDefinition * {
   auto it = impl->operationToIdx.find(op);
   return it == impl->operationToIdx.end() ? nullptr
                                           : &*impl->operations[it->second];
 }
 
-llvm::SMRange AsmParserState::convertIdLocToRange(llvm::SMLoc loc) {
+SMRange AsmParserState::convertIdLocToRange(SMLoc loc) {
   if (!loc.isValid())
-    return llvm::SMRange();
+    return SMRange();
 
   // Return if the given character is a valid identifier character.
   auto isIdentifierChar = [](char c) {
     return isalnum(c) || c == '$' || c == '.' || c == '_' || c == '-';
   };
 
   const char *curPtr = loc.getPointer();
   while (*curPtr && isIdentifierChar(*(++curPtr)))
     continue;
-  return llvm::SMRange(loc, llvm::SMLoc::getFromPointer(curPtr));
+  return SMRange(loc, SMLoc::getFromPointer(curPtr));
 }
 
 //===----------------------------------------------------------------------===//
 // Populate State
 
 void AsmParserState::initialize(Operation *topLevelOp) {
   startOperationDefinition(topLevelOp->getName());
 
void AsmParserState::finalize(Operation *topLevelOp) {
   impl->resolveSymbolUses();
 }
 
 void AsmParserState::startOperationDefinition(const OperationName &opName) {
   impl->partialOperations.emplace_back(opName);
 }
 
 void AsmParserState::finalizeOperationDefinition(
-    Operation *op, llvm::SMRange nameLoc, llvm::SMLoc endLoc,
-    ArrayRef<std::pair<unsigned, llvm::SMLoc>> resultGroups) {
+    Operation *op, SMRange nameLoc, SMLoc endLoc,
+    ArrayRef<std::pair<unsigned, SMLoc>> resultGroups) {
   assert(!impl->partialOperations.empty() &&
          "expected valid partial operation definition");
   Impl::PartialOpDef partialOpDef = impl->partialOperations.pop_back_val();
 
   // Build the full operation definition.
   std::unique_ptr<OperationDefinition> def =
       std::make_unique<OperationDefinition>(op, nameLoc, endLoc);
   for (auto &resultGroup : resultGroups)
void AsmParserState::finalizeRegionDefinition() {
 
   // If the parent operation of this region is a symbol table, pop the symbol
   // scope for this region.
   Impl::PartialOpDef &partialOpDef = impl->partialOperations.back();
   if (partialOpDef.isSymbolTable())
     impl->symbolUseScopes.pop_back();
 }
 
-void AsmParserState::addDefinition(Block *block, llvm::SMLoc location) {
+void AsmParserState::addDefinition(Block *block, SMLoc location) {
   auto it = impl->blocksToIdx.find(block);
   if (it == impl->blocksToIdx.end()) {
     impl->blocksToIdx.try_emplace(block, impl->blocks.size());
     impl->blocks.emplace_back(std::make_unique<BlockDefinition>(
         block, convertIdLocToRange(location)));
     return;
   }
 
   // If an entry already exists, this was a forward declaration that now has a
   // proper definition.
   impl->blocks[it->second]->definition.loc = convertIdLocToRange(location);
 }
 
 void AsmParserState::addDefinition(BlockArgument blockArg,
-                                   llvm::SMLoc location) {
+                                   SMLoc location) {
   auto it = impl->blocksToIdx.find(blockArg.getOwner());
   assert(it != impl->blocksToIdx.end() &&
          "expected owner block to have an entry");
   BlockDefinition &def = *impl->blocks[it->second];
   unsigned argIdx = blockArg.getArgNumber();
 
   if (def.arguments.size() <= argIdx)
     def.arguments.resize(argIdx + 1);
   def.arguments[argIdx] = SMDefinition(convertIdLocToRange(location));
 }
 
-void AsmParserState::addUses(Value value, ArrayRef<llvm::SMLoc> locations) {
+void AsmParserState::addUses(Value value, ArrayRef<SMLoc> locations) {
   // Handle the case where the value is an operation result.
   if (OpResult result = value.dyn_cast<OpResult>()) {
     // Check to see if a definition for the parent operation has been recorded.
     // If one hasn't, we treat the provided value as a placeholder value that
     // will be refined further later.
     Operation *parentOp = result.getOwner();
     auto existingIt = impl->operationToIdx.find(parentOp);
     if (existingIt == impl->operationToIdx.end()) {
       impl->placeholderValueUses[value].append(locations.begin(),
                                                locations.end());
       return;
     }
 
     // If a definition does exist, locate the value's result group and add the
     // use. The result groups are ordered by increasing start index, so we just
     // need to find the last group that has a smaller/equal start index.
     unsigned resultNo = result.getResultNumber();
     OperationDefinition &def = *impl->operations[existingIt->second];
     for (auto &resultGroup : llvm::reverse(def.resultGroups)) {
       if (resultNo >= resultGroup.startIndex) {
-        for (llvm::SMLoc loc : locations)
+        for (SMLoc loc : locations)
           resultGroup.definition.uses.push_back(convertIdLocToRange(loc));
         return;
       }
     }
     llvm_unreachable("expected valid result group for value use");
   }
 
   // Otherwise, this is a block argument.
   BlockArgument arg = value.cast<BlockArgument>();
   auto existingIt = impl->blocksToIdx.find(arg.getOwner());
   assert(existingIt != impl->blocksToIdx.end() &&
          "expected valid block definition for block argument");
   BlockDefinition &blockDef = *impl->blocks[existingIt->second];
   SMDefinition &argDef = blockDef.arguments[arg.getArgNumber()];
-  for (llvm::SMLoc loc : locations)
+  for (SMLoc loc : locations)
     argDef.uses.emplace_back(convertIdLocToRange(loc));
 }
 
-void AsmParserState::addUses(Block *block, ArrayRef<llvm::SMLoc> locations) {
+void AsmParserState::addUses(Block *block, ArrayRef<SMLoc> locations) {
   auto it = impl->blocksToIdx.find(block);
   if (it == impl->blocksToIdx.end()) {
     it = impl->blocksToIdx.try_emplace(block, impl->blocks.size()).first;
     impl->blocks.emplace_back(std::make_unique<BlockDefinition>(block));
   }
 
   BlockDefinition &def = *impl->blocks[it->second];
-  for (llvm::SMLoc loc : locations)
+  for (SMLoc loc : locations)
     def.definition.uses.push_back(convertIdLocToRange(loc));
 }
 
 void AsmParserState::addUses(SymbolRefAttr refAttr,
-                             ArrayRef<llvm::SMRange> locations) {
+                             ArrayRef<SMRange> locations) {
   // Ignore this symbol if no scopes are active.
   if (impl->symbolUseScopes.empty())
     return;
 
   assert((refAttr.getNestedReferences().size() + 1) == locations.size() &&
          "expected the same number of references as provided locations");
   (*impl->symbolUseScopes.back())[refAttr].emplace_back(locations.begin(),
                                                         locations.end());

mlir/lib/Parser/AttributeParser.cpp

case Token::string: {
     return type ? StringAttr::get(val, type)
                 : StringAttr::get(getContext(), val);
   }
 
   // Parse a symbol reference attribute.
   case Token::at_identifier: {
     // When populating the parser state, this is a list of locations for all of
     // the nested references.
-    SmallVector<llvm::SMRange> referenceLocations;
+    SmallVector<SMRange> referenceLocations;
     if (state.asmState)
       referenceLocations.push_back(getToken().getLocRange());
 
     // Parse the top-level reference.
     std::string nameStr = getToken().getSymbolReference();
     consumeToken(Token::at_identifier);
 
     // Parse any nested references.
static Optional<APInt> buildAttributeAPInt(Type type, bool isNegative,
   return result;
 }
 
 /// Parse a decimal or a hexadecimal literal, which can be either an integer
 /// or a float attribute.
 Attribute Parser::parseDecOrHexAttr(Type type, bool isNegative) {
   Token tok = getToken();
   StringRef spelling = tok.getSpelling();
-  llvm::SMLoc loc = tok.getLoc();
+  SMLoc loc = tok.getLoc();
 
   consumeToken(Token::integer);
   if (!type) {
     // Default to i64 if not type is specified.
     if (!consumeIf(Token::colon))
       type = builder.getIntegerType(64);
     else if (!(type = parseType()))
       return nullptr;
public:
   TensorLiteralParser(Parser &p) : p(p) {}
 
   /// Parse the elements of a tensor literal. If 'allowHex' is true, the parser
   /// may also parse a tensor literal that is store as a hex string.
   ParseResult parse(bool allowHex);
 
   /// Build a dense attribute instance with the parsed elements and the given
   /// shaped type.
-  DenseElementsAttr getAttr(llvm::SMLoc loc, ShapedType type);
+  DenseElementsAttr getAttr(SMLoc loc, ShapedType type);
 
   ArrayRef<int64_t> getShape() const { return shape; }
 
 private:
   /// Get the parsed elements for an integer attribute.
-  ParseResult getIntAttrElements(llvm::SMLoc loc, Type eltTy,
+  ParseResult getIntAttrElements(SMLoc loc, Type eltTy,
                                  std::vector<APInt> &intValues);
 
   /// Get the parsed elements for a float attribute.
-  ParseResult getFloatAttrElements(llvm::SMLoc loc, FloatType eltTy,
+  ParseResult getFloatAttrElements(SMLoc loc, FloatType eltTy,
                                    std::vector<APFloat> &floatValues);
 
   /// Build a Dense String attribute for the given type.
-  DenseElementsAttr getStringAttr(llvm::SMLoc loc, ShapedType type, Type eltTy);
+  DenseElementsAttr getStringAttr(SMLoc loc, ShapedType type, Type eltTy);
 
   /// Build a Dense attribute with hex data for the given type.
-  DenseElementsAttr getHexAttr(llvm::SMLoc loc, ShapedType type);
+  DenseElementsAttr getHexAttr(SMLoc loc, ShapedType type);
 
   /// Parse a single element, returning failure if it isn't a valid element
   /// literal. For example:
   /// parseElement(1) -> Success, 1
   /// parseElement([1]) -> Failure
   ParseResult parseElement();
 
   /// Parse a list of either lists or elements, returning the dimensions of the
ParseResult TensorLiteralParser::parse(bool allowHex) {
   // Otherwise, parse a list or an individual element.
   if (p.getToken().is(Token::l_square))
     return parseList(shape);
   return parseElement();
 }
 
 /// Build a dense attribute instance with the parsed elements and the given
 /// shaped type.
-DenseElementsAttr TensorLiteralParser::getAttr(llvm::SMLoc loc,
+DenseElementsAttr TensorLiteralParser::getAttr(SMLoc loc,
                                                ShapedType type) {
   Type eltType = type.getElementType();
 
   // Check to see if we parse the literal from a hex string.
   if (hexStorage.hasValue() &&
       (eltType.isIntOrIndexOrFloat() || eltType.isa<ComplexType>()))
     return getHexAttr(loc, type);
 
DenseElementsAttr TensorLiteralParser::getAttr(SMLoc loc,
   }
 
   // Other types are assumed to be string representations.
   return getStringAttr(loc, type, type.getElementType());
 }
 
 /// Build a Dense Integer attribute for the given type.
 ParseResult
-TensorLiteralParser::getIntAttrElements(llvm::SMLoc loc, Type eltTy,
+TensorLiteralParser::getIntAttrElements(SMLoc loc, Type eltTy,
                                         std::vector<APInt> &intValues) {
   intValues.reserve(storage.size());
   bool isUintType = eltTy.isUnsignedInteger();
   for (const auto &signAndToken : storage) {
     bool isNegative = signAndToken.first;
     const Token &token = signAndToken.second;
     auto tokenLoc = token.getLoc();
 
if (!apInt)
       return p.emitError(tokenLoc, "integer constant out of range for type");
     intValues.push_back(*apInt);
   }
   return success();
 }
 
 /// Build a Dense Float attribute for the given type.
 ParseResult
-TensorLiteralParser::getFloatAttrElements(llvm::SMLoc loc, FloatType eltTy,
+TensorLiteralParser::getFloatAttrElements(SMLoc loc, FloatType eltTy,
                                           std::vector<APFloat> &floatValues) {
   floatValues.reserve(storage.size());
   for (const auto &signAndToken : storage) {
     bool isNegative = signAndToken.first;
     const Token &token = signAndToken.second;
 
     // Handle hexadecimal float literals.
     if (token.is(Token::integer) && token.getSpelling().startswith("0x")) {
if (!eltTy.isF64()) {
                     &unused);
     }
     floatValues.push_back(apVal);
   }
   return success();
 }
 
 /// Build a Dense String attribute for the given type.
-DenseElementsAttr TensorLiteralParser::getStringAttr(llvm::SMLoc loc,
+DenseElementsAttr TensorLiteralParser::getStringAttr(SMLoc loc,
                                                      ShapedType type,
                                                      Type eltTy) {
   if (hexStorage.hasValue()) {
     auto stringValue = hexStorage.getValue().getStringValue();
     return DenseStringElementsAttr::get(type, {stringValue});
   }
 
   std::vector<std::string> stringValues;
   std::vector<StringRef> stringRefValues;
   stringValues.reserve(storage.size());
   stringRefValues.reserve(storage.size());
 
   for (auto val : storage) {
     stringValues.push_back(val.second.getStringValue());
     stringRefValues.emplace_back(stringValues.back());
   }
 
   return DenseStringElementsAttr::get(type, stringRefValues);
 }
 
 /// Build a Dense attribute with hex data for the given type.
-DenseElementsAttr TensorLiteralParser::getHexAttr(llvm::SMLoc loc,
+DenseElementsAttr TensorLiteralParser::getHexAttr(SMLoc loc,
                                                   ShapedType type) {
   Type elementType = type.getElementType();
   if (!elementType.isIntOrIndexOrFloat() && !elementType.isa<ComplexType>()) {
     p.emitError(loc)
         << "expected floating-point, integer, or complex element type, got "
         << elementType;
     return nullptr;
   }
Attribute Parser::parseDenseElementsAttr(Type attrType) {
   auto type = parseElementsLiteralType(attrType);
   if (!type)
     return nullptr;
   return literalParser.getAttr(loc, type);
 }
 
 /// Parse an opaque elements attribute.
 Attribute Parser::parseOpaqueElementsAttr(Type attrType) {
-  llvm::SMLoc loc = getToken().getLoc();
+  SMLoc loc = getToken().getLoc();
   consumeToken(Token::kw_opaque);
   if (parseToken(Token::less, "expected '<' after 'opaque'"))
     return nullptr;
 
   if (getToken().isNot(Token::string))
     return (emitError("expected dialect namespace"), nullptr);
 
   std::string name = getToken().getStringValue();
ShapedType Parser::parseElementsLiteralType(Type type) {
   if (!sType.hasStaticShape())
     return (emitError("elements literal type must have static shape"), nullptr);
 
   return sType;
 }
 
 /// Parse a sparse elements attribute.
 Attribute Parser::parseSparseElementsAttr(Type attrType) {
-  llvm::SMLoc loc = getToken().getLoc();
+  SMLoc loc = getToken().getLoc();
   consumeToken(Token::kw_sparse);
   if (parseToken(Token::less, "Expected '<' after 'sparse'"))
     return nullptr;
 
   // Check for the case where all elements are sparse. The indices are
   // represented by a 2-dimensional shape where the second dimension is the rank
   // of the type.
   Type indiceEltType = builder.getIntegerType(64);

mlir/lib/Parser/DialectSymbolParser.cpp

 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/DialectImplementation.h"
 #include "llvm/Support/SourceMgr.h"
 
 using namespace mlir;
 using namespace mlir::detail;
 using llvm::MemoryBuffer;
-using llvm::SMLoc;
 using llvm::SourceMgr;
 
 namespace {
 /// This class provides the main implementation of the DialectAsmParser that
 /// allows for dialects to parse attributes and types. This allows for dialect
 /// hooking into the main MLIR parsing logic.
 class CustomDialectAsmParser : public AsmParserImpl<DialectAsmParser> {
 public:
if (!identifier.contains('.')) {
     if (p.parseToken(Token::less, "expected '<' in dialect type"))
       return nullptr;
 
     // Parse the symbol specific data.
     if (p.getToken().isNot(Token::string))
       return (p.emitError("expected string literal data in dialect symbol"),
               nullptr);
     symbolData = p.getToken().getStringValue();
-    loc = llvm::SMLoc::getFromPointer(p.getToken().getLoc().getPointer() + 1);
+    loc = SMLoc::getFromPointer(p.getToken().getLoc().getPointer() + 1);
     p.consumeToken(Token::string);
 
     // Consume the '>'.
     if (p.parseToken(Token::greater, "expected '>' in dialect symbol"))
       return nullptr;
   } else {
     // Ok, the dialect name is the part of the identifier before the dot, the
     // part after the dot is the dialect's symbol, or the start thereof.
     auto dotHalves = identifier.split('.');
     dialectName = dotHalves.first;
     auto prettyName = dotHalves.second;
-    loc = llvm::SMLoc::getFromPointer(prettyName.data());
+    loc = SMLoc::getFromPointer(prettyName.data());
 
     // If the dialect's symbol is followed immediately by a <, then lex the body
     // of it into prettyName.
     if (p.getToken().is(Token::less) &&
         prettyName.bytes_end() == p.getTokenSpelling().bytes_begin()) {
       if (p.parsePrettyDialectSymbolName(prettyName))
         return nullptr;
     }
 
     symbolData = prettyName.str();
   }
 
   // Record the name location of the type remapped to the top level buffer.
-  llvm::SMLoc locInTopLevelBuffer = p.remapLocationToTopLevelBuffer(loc);
+  SMLoc locInTopLevelBuffer = p.remapLocationToTopLevelBuffer(loc);
   p.getState().symbols.nestedParserLocs.push_back(locInTopLevelBuffer);
 
   // Call into the provided symbol construction function.
   Symbol sym = createSymbol(dialectName, symbolData, loc);
 
   // Pop the last parser location.
   p.getState().symbols.nestedParserLocs.pop_back();
   return sym;

 ///   extended-attribute ::= (dialect-attribute | attribute-alias)
 ///   dialect-attribute  ::= `#` dialect-namespace `<` `"` attr-data `"` `>`
 ///   dialect-attribute  ::= `#` alias-name pretty-dialect-sym-body?
 ///   attribute-alias    ::= `#` alias-name
 ///
 Attribute Parser::parseExtendedAttr(Type type) {
   Attribute attr = parseExtendedSymbol<Attribute>(
       *this, Token::hash_identifier, state.symbols.attributeAliasDefinitions,
       [&](StringRef dialectName, StringRef symbolData,
-          llvm::SMLoc loc) -> Attribute {
+          SMLoc loc) -> Attribute {
         // Parse an optional trailing colon type.
         Type attrType = type;
         if (consumeIf(Token::colon) && !(attrType = parseType()))
           return Attribute();
 
         // If we found a registered dialect, then ask it to parse the attribute.
         if (Dialect *dialect =
                 builder.getContext()->getOrLoadDialect(dialectName)) {

 ///   extended-type ::= (dialect-type | type-alias)
 ///   dialect-type  ::= `!` dialect-namespace `<` `"` type-data `"` `>`
 ///   dialect-type  ::= `!` alias-name pretty-dialect-attribute-body?
 ///   type-alias    ::= `!` alias-name
 ///
 Type Parser::parseExtendedType() {
   return parseExtendedSymbol<Type>(
       *this, Token::exclamation_identifier, state.symbols.typeAliasDefinitions,
       [&](StringRef dialectName, StringRef symbolData,
-          llvm::SMLoc loc) -> Type {
+          SMLoc loc) -> Type {
         // If we found a registered dialect, then ask it to parse the type.
         auto *dialect = state.context->getOrLoadDialect(dialectName);
 
         if (dialect) {
           return parseSymbol<Type>(
               symbolData, state.context, state.symbols, [&](Parser &parser) {
                 CustomDialectAsmParser customParser(symbolData, parser);
                 return dialect->parseType(customParser);

mlir/lib/Parser/Lexer.h

public:
   explicit Lexer(const llvm::SourceMgr &sourceMgr, MLIRContext *context);
 
   const llvm::SourceMgr &getSourceMgr() { return sourceMgr; }
 
   Token lexToken();
 
   /// Encode the specified source location information into a Location object
   /// for attachment to the IR or error reporting.
-  Location getEncodedSourceLocation(llvm::SMLoc loc);
+  Location getEncodedSourceLocation(SMLoc loc);
 
   /// Change the position of the lexer cursor.  The next token we lex will start
   /// at the designated point in the input.
   void resetPointer(const char *newPointer) { curPtr = newPointer; }
 
   /// Returns the start of the buffer.
   const char *getBufferBegin() { return curBuffer.data(); }
 

mlir/lib/Parser/Lexer.cpp

 
 #include "Lexer.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/Location.h"
 #include "mlir/IR/MLIRContext.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/SourceMgr.h"
-using namespace mlir;
 
-using llvm::SMLoc;
+using namespace mlir;
 
 // Returns true if 'c' is an allowable punctuation character: [$._-]
 // Returns false otherwise.
 static bool isPunct(char c) {
   return c == '$' || c == '.' || c == '_' || c == '-';
 }
 
 Lexer::Lexer(const llvm::SourceMgr &sourceMgr, MLIRContext *context)
     : sourceMgr(sourceMgr), context(context) {
   auto bufferID = sourceMgr.getMainFileID();
   curBuffer = sourceMgr.getMemoryBuffer(bufferID)->getBuffer();
   curPtr = curBuffer.begin();
 }
 
 /// Encode the specified source location information into an attribute for
 /// attachment to the IR.
-Location Lexer::getEncodedSourceLocation(llvm::SMLoc loc) {
+Location Lexer::getEncodedSourceLocation(SMLoc loc) {
   auto &sourceMgr = getSourceMgr();
   unsigned mainFileID = sourceMgr.getMainFileID();
 
   // TODO: Fix performance issues in SourceMgr::getLineAndColumn so that we can
   //       use it here.
   auto &bufferInfo = sourceMgr.getBufferInfo(mainFileID);
   unsigned lineNo = bufferInfo.getLineNumber(loc.getPointer());
   unsigned column =

mlir/lib/Parser/Parser.h

public:
   //===--------------------------------------------------------------------===//
   // Error Handling
   //===--------------------------------------------------------------------===//
 
   /// Emit an error and return failure.
   InFlightDiagnostic emitError(const Twine &message = {}) {
     return emitError(state.curToken.getLoc(), message);
   }
-  InFlightDiagnostic emitError(llvm::SMLoc loc, const Twine &message = {});
+  InFlightDiagnostic emitError(SMLoc loc, const Twine &message = {});
 
   /// Encode the specified source location information into an attribute for
   /// attachment to the IR.
-  Location getEncodedSourceLocation(llvm::SMLoc loc) {
+  Location getEncodedSourceLocation(SMLoc loc) {
     // If there are no active nested parsers, we can get the encoded source
     // location directly.
     if (state.parserDepth == 0)
       return state.lex.getEncodedSourceLocation(loc);
     // Otherwise, we need to re-encode it to point to the top level buffer.
     return state.symbols.topLevelLexer->getEncodedSourceLocation(
         remapLocationToTopLevelBuffer(loc));
   }
 
   /// Remaps the given SMLoc to the top level lexer of the parser. This is used
   /// to adjust locations of potentially nested parsers to ensure that they can
   /// be emitted properly as diagnostics.
-  llvm::SMLoc remapLocationToTopLevelBuffer(llvm::SMLoc loc) {
+  SMLoc remapLocationToTopLevelBuffer(SMLoc loc) {
     // If there are no active nested parsers, we can return location directly.
     SymbolState &symbols = state.symbols;
     if (state.parserDepth == 0)
       return loc;
     assert(symbols.topLevelLexer && "expected valid top-level lexer");
 
     // Otherwise, we need to remap the location to the main parser. This is
     // simply offseting the location onto the location of the last nested
     // parser.
     size_t offset = loc.getPointer() - state.lex.getBufferBegin();
     auto *rawLoc =
         symbols.nestedParserLocs[state.parserDepth - 1].getPointer() + offset;
-    return llvm::SMLoc::getFromPointer(rawLoc);
+    return SMLoc::getFromPointer(rawLoc);
   }
 
   //===--------------------------------------------------------------------===//
   // Token Parsing
   //===--------------------------------------------------------------------===//
 
   /// Return the current token the parser is inspecting.
   const Token &getToken() const { return state.curToken; }
public:
   // Type Parsing
   //===--------------------------------------------------------------------===//
 
   /// Invoke the `getChecked` method of the given Attribute or Type class, using
   /// the provided location to emit errors in the case of failure. Note that
   /// unlike `OpBuilder::getType`, this method does not implicitly insert a
   /// context parameter.
   template <typename T, typename... ParamsT>
-  T getChecked(llvm::SMLoc loc, ParamsT &&...params) {
+  T getChecked(SMLoc loc, ParamsT &&...params) {
     return T::getChecked([&] { return emitError(loc); },
                          std::forward<ParamsT>(params)...);
   }
 
   ParseResult parseFunctionResultTypes(SmallVectorImpl<Type> &elements);
   ParseResult parseTypeListNoParens(SmallVectorImpl<Type> &elements);
   ParseResult parseTypeListParens(SmallVectorImpl<Type> &elements);
 

mlir/lib/Parser/Parser.cpp

 #include "llvm/ADT/bit.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/SourceMgr.h"
 #include <algorithm>
 
 using namespace mlir;
 using namespace mlir::detail;
 using llvm::MemoryBuffer;
-using llvm::SMLoc;
 using llvm::SourceMgr;
 
 //===----------------------------------------------------------------------===//
 // Parser
 //===----------------------------------------------------------------------===//
 
 /// Parse a list of comma-separated items with an optional delimiter.  If a
 /// delimiter is provided, then an empty list is allowed.  If not, then at
OptionalParseResult Parser::parseOptionalInteger(APInt &result) {
 
   return success();
 }
 
 /// Parse a floating point value from an integer literal token.
 ParseResult Parser::parseFloatFromIntegerLiteral(
     Optional<APFloat> &result, const Token &tok, bool isNegative,
     const llvm::fltSemantics &semantics, size_t typeSizeInBits) {
-  llvm::SMLoc loc = tok.getLoc();
+  SMLoc loc = tok.getLoc();
   StringRef spelling = tok.getSpelling();
   bool isHex = spelling.size() > 1 && spelling[1] == 'x';
   if (!isHex) {
     return emitError(loc, "unexpected decimal integer literal for a "
                           "floating point value")
                .attachNote()
            << "add a trailing dot to make the literal a float";
   }
public:
   /// region is isolated from those above.
   ParseResult parseRegion(Region &region,
                           ArrayRef<std::pair<SSAUseInfo, Type>> entryArguments,
                           ArrayRef<Location> argLocations,
                           bool isIsolatedNameScope = false);
 
   /// Parse a region body into 'region'.
   ParseResult
-  parseRegionBody(Region &region, llvm::SMLoc startLoc,
+  parseRegionBody(Region &region, SMLoc startLoc,
                   ArrayRef<std::pair<SSAUseInfo, Type>> entryArguments,
                   ArrayRef<Location> argLocations, bool isIsolatedNameScope);
 
   //===--------------------------------------------------------------------===//
   // Block Parsing
   //===--------------------------------------------------------------------===//
 
   /// Parse a new block into 'block'.
if (!resultIDs.empty()) {
     if (numExpectedResults != op->getNumResults())
       return emitError(loc, "operation defines ")
              << op->getNumResults() << " results but was provided "
              << numExpectedResults << " to bind";
 
     // Add this operation to the assembly state if it was provided to populate.
     if (state.asmState) {
       unsigned resultIt = 0;
-      SmallVector<std::pair<unsigned, llvm::SMLoc>> asmResultGroups;
+      SmallVector<std::pair<unsigned, SMLoc>> asmResultGroups;
       asmResultGroups.reserve(resultIDs.size());
       for (ResultRecord &record : resultIDs) {
         asmResultGroups.emplace_back(resultIt, std::get<2>(record));
         resultIt += std::get<1>(record);
       }
       state.asmState->finalizeOperationDefinition(
           op, nameTok.getLocRange(), /*endLoc=*/getToken().getLoc(),
           asmResultGroups);
public:
   size_t getNumResults() const override {
     size_t count = 0;
     for (auto &entry : resultIDs)
       count += std::get<1>(entry);
     return count;
   }
 
   /// Emit a diagnostic at the specified location and return failure.
-  InFlightDiagnostic emitError(llvm::SMLoc loc, const Twine &message) override {
+  InFlightDiagnostic emitError(SMLoc loc, const Twine &message) override {
     return AsmParserImpl<OpAsmParser>::emitError(loc, "custom op '" + opName +
                                                           "' " + message);
   }
 
   //===--------------------------------------------------------------------===//
   // Operand Parsing
   //===--------------------------------------------------------------------===//
 
if (opInfo) {
     }
   }
 
   return OperationName(opName, getContext());
 }
 
 Operation *
 OperationParser::parseCustomOperation(ArrayRef<ResultRecord> resultIDs) {
-  llvm::SMLoc opLoc = getToken().getLoc();
+  SMLoc opLoc = getToken().getLoc();
 
   FailureOr<OperationName> opNameInfo = parseCustomOperationName();
   if (failed(opNameInfo))
     return nullptr;
 
   StringRef opName = opNameInfo->getStringRef();
   Dialect *dialect = opNameInfo->getDialect();
   Optional<RegisteredOperationName> opInfo = opNameInfo->getRegisteredInfo();
ParseResult OperationParser::parseRegion(
   // If we are populating the parser state, finalize this region.
   if (state.asmState)
     state.asmState->finalizeRegionDefinition();
 
   return success();
 }
 
 ParseResult OperationParser::parseRegionBody(
-    Region &region, llvm::SMLoc startLoc,
+    Region &region, SMLoc startLoc,
     ArrayRef<std::pair<OperationParser::SSAUseInfo, Type>> entryArguments,
     ArrayRef<Location> argLocations, bool isIsolatedNameScope) {
   assert(argLocations.empty() || argLocations.size() == entryArguments.size());
   auto currentPt = opBuilder.saveInsertionPoint();
 
   // Push a new named value scope.
   pushSSANameScope(isIsolatedNameScope);
 
return emitError(mlir::UnknownLoc::get(context),
                      "only main buffer parsed at the moment");
   }
   auto fileOrErr = llvm::MemoryBuffer::getFileOrSTDIN(filename);
   if (std::error_code error = fileOrErr.getError())
     return emitError(mlir::UnknownLoc::get(context),
                      "could not open input file " + filename);
 
   // Load the MLIR source file.
-  sourceMgr.AddNewSourceBuffer(std::move(*fileOrErr), llvm::SMLoc());
+  sourceMgr.AddNewSourceBuffer(std::move(*fileOrErr), SMLoc());
   return parseSourceFile(sourceMgr, block, context, sourceFileLoc, asmState);
 }
 
 LogicalResult mlir::parseSourceString(llvm::StringRef sourceStr, Block *block,
                                       MLIRContext *context,
                                       LocationAttr *sourceFileLoc) {
   auto memBuffer = MemoryBuffer::getMemBuffer(sourceStr);
   if (!memBuffer)
     return failure();
 
   SourceMgr sourceMgr;
   sourceMgr.AddNewSourceBuffer(std::move(memBuffer), SMLoc());
   return parseSourceFile(sourceMgr, block, context, sourceFileLoc);
 }

mlir/lib/Parser/ParserState.h

struct SymbolState {
 
   // A map from type alias identifier to Type.
   llvm::StringMap<Type> typeAliasDefinitions;
 
   /// A set of locations into the main parser memory buffer for each of the
   /// active nested parsers. Given that some nested parsers, i.e. custom dialect
   /// parsers, operate on a temporary memory buffer, this provides an anchor
   /// point for emitting diagnostics.
-  SmallVector<llvm::SMLoc, 1> nestedParserLocs;
+  SmallVector<SMLoc, 1> nestedParserLocs;
 
   /// The top-level lexer that contains the original memory buffer provided by
   /// the user. This is used by nested parsers to get a properly encoded source
   /// location.
   Lexer *topLevelLexer = nullptr;
 };
 
 //===----------------------------------------------------------------------===//

mlir/lib/Parser/Token.h

#include "TokenKinds.def"
   /// string starting with `0x` and only containing hex digits.
   Optional<std::string> getHexStringValue() const;
 
   /// Given a token containing a symbol reference, return the unescaped string
   /// value.
   std::string getSymbolReference() const;
 
   // Location processing.
-  llvm::SMLoc getLoc() const;
-  llvm::SMLoc getEndLoc() const;
-  llvm::SMRange getLocRange() const;
+  SMLoc getLoc() const;
+  SMLoc getEndLoc() const;
+  SMRange getLocRange() const;
 
   /// Given a punctuation or keyword token kind, return the spelling of the
   /// token as a string.  Warning: This will abort on markers, identifiers and
   /// literal tokens since they have no fixed spelling.
   static StringRef getTokenSpelling(Kind kind);
 
 private:
   /// Discriminator that indicates the sort of token this is.

mlir/lib/Parser/Token.cpp

 //===- Token.cpp - MLIR Token Implementation ------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the Token class for the MLIR textual form.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Token.h"
 #include "llvm/ADT/StringExtras.h"
+
 using namespace mlir;
-using llvm::SMLoc;
-using llvm::SMRange;
 
 SMLoc Token::getLoc() const { return SMLoc::getFromPointer(spelling.data()); }
 
 SMLoc Token::getEndLoc() const {
   return SMLoc::getFromPointer(spelling.data() + spelling.size());
 }
 
 SMRange Token::getLocRange() const { return SMRange(getLoc(), getEndLoc()); }

mlir/lib/Parser/TypeParser.cpp

 ///
 Type Parser::parseComplexType() {
   consumeToken(Token::kw_complex);
 
   // Parse the '<'.
   if (parseToken(Token::less, "expected '<' in complex type"))
     return nullptr;
 
-  llvm::SMLoc elementTypeLoc = getToken().getLoc();
+  SMLoc elementTypeLoc = getToken().getLoc();
   auto elementType = parseType();
   if (!elementType ||
       parseToken(Token::greater, "expected '>' in complex type"))
     return nullptr;
   if (!elementType.isa<FloatType>() && !elementType.isa<IntegerType>())
     return emitError(elementTypeLoc, "invalid element type for complex"),
            nullptr;
 

 ///   unranked-memref-type ::= `memref` `<*x` type (`,` memory-space)? `>`
 ///
 ///   stride-list ::= `[` (dimension (`,` dimension)*)? `]`
 ///   strided-layout ::= `offset:` dimension `,` `strides: ` stride-list
 ///   layout-specification ::= semi-affine-map | strided-layout | attribute
 ///   memory-space ::= integer-literal | attribute
 ///
 Type Parser::parseMemRefType() {
-  llvm::SMLoc loc = getToken().getLoc();
+  SMLoc loc = getToken().getLoc();
   consumeToken(Token::kw_memref);
 
   if (parseToken(Token::less, "expected '<' in memref type"))
     return nullptr;
 
   bool isUnranked;
   SmallVector<int64_t, 4> dimensions;
 

mlir/lib/Pass/PassRegistry.cpp

LogicalResult TextualPipeline::initialize(StringRef text,
   if (text.empty())
     return success();
 
   // Build a source manager to use for error reporting.
   llvm::SourceMgr pipelineMgr;
   pipelineMgr.AddNewSourceBuffer(
       llvm::MemoryBuffer::getMemBuffer(text, "MLIR Textual PassPipeline Parser",
                                        /*RequiresNullTerminator=*/false),
-      llvm::SMLoc());
+      SMLoc());
   auto errorHandler = [&](const char *rawLoc, Twine msg) {
-    pipelineMgr.PrintMessage(errorStream, llvm::SMLoc::getFromPointer(rawLoc),
+    pipelineMgr.PrintMessage(errorStream, SMLoc::getFromPointer(rawLoc),
                              llvm::SourceMgr::DK_Error, msg);
     return failure();
   };
 
   // Parse the provided pipeline string.
   if (failed(parsePipelineText(text, errorHandler)))
     return failure();
   return resolvePipelineElements(pipeline, errorHandler);

mlir/lib/Support/MlirOptMain.cpp

 #include "llvm/Support/Regex.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/StringSaver.h"
 #include "llvm/Support/ThreadPool.h"
 #include "llvm/Support/ToolOutputFile.h"
 
 using namespace mlir;
 using namespace llvm;
-using llvm::SMLoc;
 
 /// Perform the actions on the input file indicated by the command line flags
 /// within the specified context.
 ///
 /// This typically parses the main source file, runs zero or more optimization
 /// passes, then prints the output.
 ///
 static LogicalResult performActions(raw_ostream &os, bool verifyDiagnostics,

mlir/lib/Support/ToolUtilities.cpp

mlir::splitAndProcessBuffer(std::unique_ptr<llvm::MemoryBuffer> originalBuffer,
   // Split dropping the last checkLen chars to enable flagging near misses.
   origMemBuffer->getBuffer().split(rawSourceBuffers,
                                    splitMarker.drop_back(checkLen));
   if (rawSourceBuffers.empty())
     return success();
 
   // Add the original buffer to the source manager.
   llvm::SourceMgr fileSourceMgr;
-  fileSourceMgr.AddNewSourceBuffer(std::move(originalBuffer), llvm::SMLoc());
+  fileSourceMgr.AddNewSourceBuffer(std::move(originalBuffer), SMLoc());
 
   // Flag near misses by iterating over all the sub-buffers found when splitting
   // with the prefix of the splitMarker. Use a sliding window where we only add
   // a buffer as a sourceBuffer if terminated by a full match of the
   // splitMarker, else flag a warning (if near miss) and extend the size of the
   // buffer under consideration.
   SmallVector<StringRef, 8> sourceBuffers;
   StringRef prev;
   for (auto buffer : rawSourceBuffers) {
     if (prev.empty()) {
       prev = buffer;
       continue;
     }
 
     // Check that suffix is as expected and doesn't have any dash post.
     bool expectedSuffix = buffer.startswith(splitMarker.take_back(checkLen)) &&
                           buffer.size() > checkLen && buffer[checkLen] != '0';
     if (expectedSuffix) {
       sourceBuffers.push_back(prev);
       prev = buffer.drop_front(checkLen);
     } else {
       // TODO: Consider making this a failure.
-      auto splitLoc = llvm::SMLoc::getFromPointer(buffer.data());
+      auto splitLoc = SMLoc::getFromPointer(buffer.data());
       fileSourceMgr.PrintMessage(llvm::errs(), splitLoc,
                                  llvm::SourceMgr::DK_Warning,
                                  "near miss with file split marker");
       prev = StringRef(prev.data(),
                        prev.size() + splitMarkerLen - checkLen + buffer.size());
     }
   }
   if (!prev.empty())
     sourceBuffers.push_back(prev);
 
   // Process each chunk in turn.
   bool hadFailure = false;
   for (auto &subBuffer : sourceBuffers) {
-    auto splitLoc = llvm::SMLoc::getFromPointer(subBuffer.data());
+    auto splitLoc = SMLoc::getFromPointer(subBuffer.data());
     unsigned splitLine = fileSourceMgr.getLineAndColumn(splitLoc).first;
     auto subMemBuffer = llvm::MemoryBuffer::getMemBufferCopy(
         subBuffer, Twine("within split at ") +
                        origMemBuffer->getBufferIdentifier() + ":" +
                        Twine(splitLine) + " offset ");
     if (failed(processChunkBuffer(std::move(subMemBuffer), os)))
       hadFailure = true;
   }
 
   // If any fails, then return a failure of the tool.
   return failure(hadFailure);
 }

mlir/lib/TableGen/AttrOrTypeDef.cpp

bool AttrOrTypeDef::genVerifyDecl() const {
   return def->getValueAsBit("genVerifyDecl");
 }
 
 Optional<StringRef> AttrOrTypeDef::getExtraDecls() const {
   auto value = def->getValueAsString("extraClassDeclaration");
   return value.empty() ? Optional<StringRef>() : value;
 }
 
-ArrayRef<llvm::SMLoc> AttrOrTypeDef::getLoc() const { return def->getLoc(); }
+ArrayRef<SMLoc> AttrOrTypeDef::getLoc() const { return def->getLoc(); }
 
 bool AttrOrTypeDef::skipDefaultBuilders() const {
   return def->getValueAsBit("skipDefaultBuilders");
 }
 
 bool AttrOrTypeDef::operator==(const AttrOrTypeDef &other) const {
   return def == other.def;
 }

mlir/lib/TableGen/Builder.cpp

Optional<StringRef> Builder::Parameter::getDefaultValue() const {
   Optional<StringRef> value = record->getValueAsOptionalString("defaultValue");
   return value && !value->empty() ? value : llvm::None;
 }
 
 //===----------------------------------------------------------------------===//
 // Builder
 //===----------------------------------------------------------------------===//
 
-Builder::Builder(const llvm::Record *record, ArrayRef<llvm::SMLoc> loc)
+Builder::Builder(const llvm::Record *record, ArrayRef<SMLoc> loc)
     : def(record) {
   // Initialize the parameters of the builder.
   const llvm::DagInit *dag = def->getValueAsDag("dagParams");
   auto *defInit = dyn_cast<llvm::DefInit>(dag->getOperator());
   if (!defInit || !defInit->getDef()->getName().equals("ins"))
     PrintFatalError(def->getLoc(), "expected 'ins' in builders");
 
   bool seenDefaultValue = false;

mlir/lib/TableGen/Operator.cpp

void Operator::populateOpStructure() {
   LLVM_DEBUG(print(llvm::dbgs()));
 }
 
 auto Operator::getSameTypeAsResult(int index) const -> ArrayRef<ArgOrType> {
   assert(allResultTypesKnown());
   return resultTypeMapping[index];
 }
 
-ArrayRef<llvm::SMLoc> Operator::getLoc() const { return def.getLoc(); }
+ArrayRef<SMLoc> Operator::getLoc() const { return def.getLoc(); }
 
 bool Operator::hasDescription() const {
   return def.getValue("description") != nullptr;
 }
 
 StringRef Operator::getDescription() const {
   return def.getValueAsString("description");
 }

mlir/lib/TableGen/Predicate.cpp

if (def->isSubClassOf("CPred"))
     return static_cast<const CPred *>(this)->getConditionImpl();
   llvm_unreachable("Pred::getCondition must be overridden in subclasses");
 }
 
 bool Pred::isCombined() const {
   return def && def->isSubClassOf("CombinedPred");
 }
 
-ArrayRef<llvm::SMLoc> Pred::getLoc() const { return def->getLoc(); }
+ArrayRef<SMLoc> Pred::getLoc() const { return def->getLoc(); }
 
 CPred::CPred(const llvm::Record *record) : Pred(record) {
   assert(def->isSubClassOf("CPred") &&
          "must be a subclass of Tablegen 'CPred' class");
 }
 
 CPred::CPred(const llvm::Init *init) : Pred(init) {
   assert((!def || def->isSubClassOf("CPred")) &&

mlir/lib/Tools/PDLL/AST/Nodes.cpp

static StringRef copyStringWithNull(Context &ctx, StringRef str) {
   data[str.size()] = 0;
   return StringRef(data, str.size());
 }
 
 //===----------------------------------------------------------------------===//
 // Name
 //===----------------------------------------------------------------------===//
 
-const Name &Name::create(Context &ctx, StringRef name, llvm::SMRange location) {
+const Name &Name::create(Context &ctx, StringRef name, SMRange location) {
   return *new (ctx.getAllocator().Allocate<Name>())
       Name(copyStringWithNull(ctx, name), location);
 }
 
 //===----------------------------------------------------------------------===//
 // DeclScope
 //===----------------------------------------------------------------------===//
 
if (Decl *decl = decls.lookup(name))
     return decl;
   return parent ? parent->lookup(name) : nullptr;
 }
 
 //===----------------------------------------------------------------------===//
 // CompoundStmt
 //===----------------------------------------------------------------------===//
 
-CompoundStmt *CompoundStmt::create(Context &ctx, llvm::SMRange loc,
+CompoundStmt *CompoundStmt::create(Context &ctx, SMRange loc,
                                    ArrayRef<Stmt *> children) {
   unsigned allocSize = CompoundStmt::totalSizeToAlloc<Stmt *>(children.size());
   void *rawData = ctx.getAllocator().Allocate(allocSize, alignof(CompoundStmt));
 
   CompoundStmt *stmt = new (rawData) CompoundStmt(loc, children.size());
   std::uninitialized_copy(children.begin(), children.end(),
                           stmt->getChildren().begin());
   return stmt;
 }
 
 //===----------------------------------------------------------------------===//
 // LetStmt
 //===----------------------------------------------------------------------===//
 
-LetStmt *LetStmt::create(Context &ctx, llvm::SMRange loc,
+LetStmt *LetStmt::create(Context &ctx, SMRange loc,
                          VariableDecl *varDecl) {
   return new (ctx.getAllocator().Allocate<LetStmt>()) LetStmt(loc, varDecl);
 }
 
 //===----------------------------------------------------------------------===//
 // OpRewriteStmt
 //===----------------------------------------------------------------------===//
 
 //===----------------------------------------------------------------------===//
 // EraseStmt
 
-EraseStmt *EraseStmt::create(Context &ctx, llvm::SMRange loc, Expr *rootOp) {
+EraseStmt *EraseStmt::create(Context &ctx, SMRange loc, Expr *rootOp) {
   return new (ctx.getAllocator().Allocate<EraseStmt>()) EraseStmt(loc, rootOp);
 }
 
 //===----------------------------------------------------------------------===//
 // ReplaceStmt
 
-ReplaceStmt *ReplaceStmt::create(Context &ctx, llvm::SMRange loc, Expr *rootOp,
+ReplaceStmt *ReplaceStmt::create(Context &ctx, SMRange loc, Expr *rootOp,
                                  ArrayRef<Expr *> replExprs) {
   unsigned allocSize = ReplaceStmt::totalSizeToAlloc<Expr *>(replExprs.size());
   void *rawData = ctx.getAllocator().Allocate(allocSize, alignof(ReplaceStmt));
 
   ReplaceStmt *stmt = new (rawData) ReplaceStmt(loc, rootOp, replExprs.size());
   std::uninitialized_copy(replExprs.begin(), replExprs.end(),
                           stmt->getReplExprs().begin());
   return stmt;
 }
 
 //===----------------------------------------------------------------------===//
 // RewriteStmt
 
-RewriteStmt *RewriteStmt::create(Context &ctx, llvm::SMRange loc, Expr *rootOp,
+RewriteStmt *RewriteStmt::create(Context &ctx, SMRange loc, Expr *rootOp,
                                  CompoundStmt *rewriteBody) {
   return new (ctx.getAllocator().Allocate<RewriteStmt>())
       RewriteStmt(loc, rootOp, rewriteBody);
 }
 
 //===----------------------------------------------------------------------===//
 // AttributeExpr
 //===----------------------------------------------------------------------===//
 
-AttributeExpr *AttributeExpr::create(Context &ctx, llvm::SMRange loc,
+AttributeExpr *AttributeExpr::create(Context &ctx, SMRange loc,
                                      StringRef value) {
   return new (ctx.getAllocator().Allocate<AttributeExpr>())
       AttributeExpr(ctx, loc, copyStringWithNull(ctx, value));
 }
 
 //===----------------------------------------------------------------------===//
 // DeclRefExpr
 //===----------------------------------------------------------------------===//
 
-DeclRefExpr *DeclRefExpr::create(Context &ctx, llvm::SMRange loc, Decl *decl,
+DeclRefExpr *DeclRefExpr::create(Context &ctx, SMRange loc, Decl *decl,
                                  Type type) {
   return new (ctx.getAllocator().Allocate<DeclRefExpr>())
       DeclRefExpr(loc, decl, type);
 }
 
 //===----------------------------------------------------------------------===//
 // MemberAccessExpr
 //===----------------------------------------------------------------------===//
 
-MemberAccessExpr *MemberAccessExpr::create(Context &ctx, llvm::SMRange loc,
+MemberAccessExpr *MemberAccessExpr::create(Context &ctx, SMRange loc,
                                            const Expr *parentExpr,
                                            StringRef memberName, Type type) {
   return new (ctx.getAllocator().Allocate<MemberAccessExpr>()) MemberAccessExpr(
       loc, parentExpr, memberName.copy(ctx.getAllocator()), type);
 }
 
 //===----------------------------------------------------------------------===//
 // OperationExpr
 //===----------------------------------------------------------------------===//
 
 OperationExpr *OperationExpr::create(
-    Context &ctx, llvm::SMRange loc, const OpNameDecl *name,
+    Context &ctx, SMRange loc, const OpNameDecl *name,
     ArrayRef<Expr *> operands, ArrayRef<Expr *> resultTypes,
     ArrayRef<NamedAttributeDecl *> attributes) {
   unsigned allocSize =
       OperationExpr::totalSizeToAlloc<Expr *, NamedAttributeDecl *>(
           operands.size() + resultTypes.size(), attributes.size());
   void *rawData =
       ctx.getAllocator().Allocate(allocSize, alignof(OperationExpr));
 

 Optional<StringRef> OperationExpr::getName() const {
   return getNameDecl()->getName();
 }
 
 //===----------------------------------------------------------------------===//
 // TupleExpr
 //===----------------------------------------------------------------------===//
 
-TupleExpr *TupleExpr::create(Context &ctx, llvm::SMRange loc,
+TupleExpr *TupleExpr::create(Context &ctx, SMRange loc,
                              ArrayRef<Expr *> elements,
                              ArrayRef<StringRef> names) {
   unsigned allocSize = TupleExpr::totalSizeToAlloc<Expr *>(elements.size());
   void *rawData = ctx.getAllocator().Allocate(allocSize, alignof(TupleExpr));
 
   auto elementTypes = llvm::map_range(
       elements, [](const Expr *expr) { return expr->getType(); });
   TupleType type = TupleType::get(ctx, llvm::to_vector(elementTypes), names);
 
   TupleExpr *expr = new (rawData) TupleExpr(loc, type);
   std::uninitialized_copy(elements.begin(), elements.end(),
                           expr->getElements().begin());
   return expr;
 }
 
 //===----------------------------------------------------------------------===//
 // TypeExpr
 //===----------------------------------------------------------------------===//
 
-TypeExpr *TypeExpr::create(Context &ctx, llvm::SMRange loc, StringRef value) {
+TypeExpr *TypeExpr::create(Context &ctx, SMRange loc, StringRef value) {
   return new (ctx.getAllocator().Allocate<TypeExpr>())
       TypeExpr(ctx, loc, copyStringWithNull(ctx, value));
 }
 
 //===----------------------------------------------------------------------===//
 // AttrConstraintDecl
 //===----------------------------------------------------------------------===//
 
-AttrConstraintDecl *AttrConstraintDecl::create(Context &ctx, llvm::SMRange loc,
+AttrConstraintDecl *AttrConstraintDecl::create(Context &ctx, SMRange loc,
                                                Expr *typeExpr) {
   return new (ctx.getAllocator().Allocate<AttrConstraintDecl>())
       AttrConstraintDecl(loc, typeExpr);
 }
 
 //===----------------------------------------------------------------------===//
 // OpConstraintDecl
 //===----------------------------------------------------------------------===//
 
-OpConstraintDecl *OpConstraintDecl::create(Context &ctx, llvm::SMRange loc,
+OpConstraintDecl *OpConstraintDecl::create(Context &ctx, SMRange loc,
                                            const OpNameDecl *nameDecl) {
   if (!nameDecl)
-    nameDecl = OpNameDecl::create(ctx, llvm::SMRange());
+    nameDecl = OpNameDecl::create(ctx, SMRange());
 
   return new (ctx.getAllocator().Allocate<OpConstraintDecl>())
       OpConstraintDecl(loc, nameDecl);
 }
 
 Optional<StringRef> OpConstraintDecl::getName() const {
   return getNameDecl()->getName();
 }
 
 //===----------------------------------------------------------------------===//
 // TypeConstraintDecl
 //===----------------------------------------------------------------------===//
 
 TypeConstraintDecl *TypeConstraintDecl::create(Context &ctx,
-                                               llvm::SMRange loc) {
+                                               SMRange loc) {
   return new (ctx.getAllocator().Allocate<TypeConstraintDecl>())
       TypeConstraintDecl(loc);
 }
 
 //===----------------------------------------------------------------------===//
 // TypeRangeConstraintDecl
 //===----------------------------------------------------------------------===//
 
 TypeRangeConstraintDecl *TypeRangeConstraintDecl::create(Context &ctx,
-                                                         llvm::SMRange loc) {
+                                                         SMRange loc) {
   return new (ctx.getAllocator().Allocate<TypeRangeConstraintDecl>())
       TypeRangeConstraintDecl(loc);
 }
 
 //===----------------------------------------------------------------------===//
 // ValueConstraintDecl
 //===----------------------------------------------------------------------===//
 
 ValueConstraintDecl *
-ValueConstraintDecl::create(Context &ctx, llvm::SMRange loc, Expr *typeExpr) {
+ValueConstraintDecl::create(Context &ctx, SMRange loc, Expr *typeExpr) {
   return new (ctx.getAllocator().Allocate<ValueConstraintDecl>())
       ValueConstraintDecl(loc, typeExpr);
 }
 
 //===----------------------------------------------------------------------===//
 // ValueRangeConstraintDecl
 //===----------------------------------------------------------------------===//
 
 ValueRangeConstraintDecl *ValueRangeConstraintDecl::create(Context &ctx,
-                                                           llvm::SMRange loc,
+                                                           SMRange loc,
                                                            Expr *typeExpr) {
   return new (ctx.getAllocator().Allocate<ValueRangeConstraintDecl>())
       ValueRangeConstraintDecl(loc, typeExpr);
 }
 
 //===----------------------------------------------------------------------===//
 // NamedAttributeDecl
 //===----------------------------------------------------------------------===//
 
 NamedAttributeDecl *NamedAttributeDecl::create(Context &ctx, const Name &name,
                                                Expr *value) {
   return new (ctx.getAllocator().Allocate<NamedAttributeDecl>())
       NamedAttributeDecl(name, value);
 }
 
 //===----------------------------------------------------------------------===//
 // OpNameDecl
 //===----------------------------------------------------------------------===//
 
 OpNameDecl *OpNameDecl::create(Context &ctx, const Name &name) {
   return new (ctx.getAllocator().Allocate<OpNameDecl>()) OpNameDecl(name);
 }
-OpNameDecl *OpNameDecl::create(Context &ctx, llvm::SMRange loc) {
+OpNameDecl *OpNameDecl::create(Context &ctx, SMRange loc) {
   return new (ctx.getAllocator().Allocate<OpNameDecl>()) OpNameDecl(loc);
 }
 
 //===----------------------------------------------------------------------===//
 // PatternDecl
 //===----------------------------------------------------------------------===//
 
-PatternDecl *PatternDecl::create(Context &ctx, llvm::SMRange loc,
+PatternDecl *PatternDecl::create(Context &ctx, SMRange loc,
                                  const Name *name, Optional<uint16_t> benefit,
                                  bool hasBoundedRecursion,
                                  const CompoundStmt *body) {
   return new (ctx.getAllocator().Allocate<PatternDecl>())
       PatternDecl(loc, name, benefit, hasBoundedRecursion, body);
 }
 
 //===----------------------------------------------------------------------===//
std::uninitialized_copy(constraints.begin(), constraints.end(),
                           varDecl->getConstraints().begin());
   return varDecl;
 }
 
 //===----------------------------------------------------------------------===//
 // Module
 //===----------------------------------------------------------------------===//
 
-Module *Module::create(Context &ctx, llvm::SMLoc loc,
+Module *Module::create(Context &ctx, SMLoc loc,
                        ArrayRef<Decl *> children) {
   unsigned allocSize = Module::totalSizeToAlloc<Decl *>(children.size());
   void *rawData = ctx.getAllocator().Allocate(allocSize, alignof(Module));
 
   Module *module = new (rawData) Module(loc, children.size());
   std::uninitialized_copy(children.begin(), children.end(),
                           module->getChildren().begin());
   return module;
 }

mlir/lib/Tools/PDLL/Parser/Lexer.h

public:
   template <typename... T> bool isNot(Kind k1, Kind k2, T... others) const {
     return !isAny(k1, k2, others...);
   }
 
   /// Return if the token has the given kind.
   bool is(Kind k) const { return kind == k; }
 
   /// Return a location for the start of this token.
-  llvm::SMLoc getStartLoc() const {
-    return llvm::SMLoc::getFromPointer(spelling.data());
+  SMLoc getStartLoc() const {
+    return SMLoc::getFromPointer(spelling.data());
   }
   /// Return a location at the end of this token.
-  llvm::SMLoc getEndLoc() const {
-    return llvm::SMLoc::getFromPointer(spelling.data() + spelling.size());
+  SMLoc getEndLoc() const {
+    return SMLoc::getFromPointer(spelling.data() + spelling.size());
   }
   /// Return a location for the range of this token.
-  llvm::SMRange getLoc() const {
-    return llvm::SMRange(getStartLoc(), getEndLoc());
+  SMRange getLoc() const {
+    return SMRange(getStartLoc(), getEndLoc());
   }
 
 private:
   /// Discriminator that indicates the kind of token this is.
   Kind kind;
 
   /// A reference to the entire token contents; this is always a pointer into
   /// a memory buffer owned by the source manager.
public:
   /// Lex the next token and return it.
   Token lexToken();
 
   /// Change the position of the lexer cursor. The next token we lex will start
   /// at the designated point in the input.
   void resetPointer(const char *newPointer) { curPtr = newPointer; }
 
   /// Emit an error to the lexer with the given location and message.
-  Token emitError(llvm::SMRange loc, const Twine &msg);
+  Token emitError(SMRange loc, const Twine &msg);
   Token emitError(const char *loc, const Twine &msg);
-  Token emitErrorAndNote(llvm::SMRange loc, const Twine &msg,
-                         llvm::SMRange noteLoc, const Twine &note);
+  Token emitErrorAndNote(SMRange loc, const Twine &msg,
+                         SMRange noteLoc, const Twine &note);
 
 private:
   Token formToken(Token::Kind kind, const char *tokStart) {
     return Token(kind, StringRef(tokStart, curPtr - tokStart));
   }
 
   /// Return the next character in the stream.
   int getNextChar();

mlir/lib/Tools/PDLL/Parser/Lexer.cpp

 
 Lexer::~Lexer() {
   if (addedHandlerToDiagEngine) diagEngine.setHandlerFn(nullptr);
 }
 
 LogicalResult Lexer::pushInclude(StringRef filename) {
   std::string includedFile;
   int bufferID = srcMgr.AddIncludeFile(
-      filename.str(), llvm::SMLoc::getFromPointer(curPtr), includedFile);
+      filename.str(), SMLoc::getFromPointer(curPtr), includedFile);
   if (!bufferID) return failure();
 
   curBufferID = bufferID;
   curBuffer = srcMgr.getMemoryBuffer(curBufferID)->getBuffer();
   curPtr = curBuffer.begin();
   return success();
 }
 
-Token Lexer::emitError(llvm::SMRange loc, const Twine &msg) {
+Token Lexer::emitError(SMRange loc, const Twine &msg) {
   diagEngine.emitError(loc, msg);
   return formToken(Token::error, loc.Start.getPointer());
 }
-Token Lexer::emitErrorAndNote(llvm::SMRange loc, const Twine &msg,
-                              llvm::SMRange noteLoc, const Twine &note) {
+Token Lexer::emitErrorAndNote(SMRange loc, const Twine &msg,
+                              SMRange noteLoc, const Twine &note) {
   diagEngine.emitError(loc, msg)->attachNote(note, noteLoc);
   return formToken(Token::error, loc.Start.getPointer());
 }
 Token Lexer::emitError(const char *loc, const Twine &msg) {
-  return emitError(llvm::SMRange(llvm::SMLoc::getFromPointer(loc),
-                                 llvm::SMLoc::getFromPointer(loc + 1)),
+  return emitError(SMRange(SMLoc::getFromPointer(loc),
+                                 SMLoc::getFromPointer(loc + 1)),
                    msg);
 }
 
 int Lexer::getNextChar() {
   char curChar = *curPtr++;
   switch (curChar) {
     default:
       return static_cast<unsigned char>(curChar);
switch (curChar) {
 
         // Unknown character, emit an error.
         return emitError(tokStart, "unexpected character");
       case EOF: {
         // Return EOF denoting the end of lexing.
         Token eof = formToken(Token::eof, tokStart);
 
         // Check to see if we are in an included file.
-        llvm::SMLoc parentIncludeLoc = srcMgr.getParentIncludeLoc(curBufferID);
+        SMLoc parentIncludeLoc = srcMgr.getParentIncludeLoc(curBufferID);
         if (parentIncludeLoc.isValid()) {
           curBufferID = srcMgr.FindBufferContainingLoc(parentIncludeLoc);
           curBuffer = srcMgr.getMemoryBuffer(curBufferID)->getBuffer();
           curPtr = parentIncludeLoc.getPointer();
         }
 
         return eof;
       }

mlir/lib/Tools/PDLL/Parser/Parser.cpp

private:
 
   /// Check to see if a decl has already been defined with the given name, if
   /// one has emit and error and return failure. Returns success otherwise.
   LogicalResult checkDefineNamedDecl(const ast::Name &name);
 
   /// Try to define a variable decl with the given components, returns the
   /// variable on success.
   FailureOr<ast::VariableDecl *>
-  defineVariableDecl(StringRef name, llvm::SMRange nameLoc, ast::Type type,
+  defineVariableDecl(StringRef name, SMRange nameLoc, ast::Type type,
                      ast::Expr *initExpr,
                      ArrayRef<ast::ConstraintRef> constraints);
   FailureOr<ast::VariableDecl *>
-  defineVariableDecl(StringRef name, llvm::SMRange nameLoc, ast::Type type,
+  defineVariableDecl(StringRef name, SMRange nameLoc, ast::Type type,
                      ArrayRef<ast::ConstraintRef> constraints);
 
   /// Parse the constraint reference list for a variable decl.
   LogicalResult parseVariableDeclConstraintList(
       SmallVectorImpl<ast::ConstraintRef> &constraints);
 
   /// Parse the expression used within a type constraint, e.g. Attr<type-expr>.
   FailureOr<ast::Expr *> parseTypeConstraintExpr();
 
   /// Try to parse a single reference to a constraint. `typeConstraint` is the
   /// location of a previously parsed type constraint for the entity that will
   /// be constrained by the parsed constraint. `existingConstraints` are any
   /// existing constraints that have already been parsed for the same entity
   /// that will be constrained by this constraint.
   FailureOr<ast::ConstraintRef>
-  parseConstraint(Optional<llvm::SMRange> &typeConstraint,
+  parseConstraint(Optional<SMRange> &typeConstraint,
                   ArrayRef<ast::ConstraintRef> existingConstraints);
 
   //===--------------------------------------------------------------------===//
   // Exprs
 
   FailureOr<ast::Expr *> parseExpr();
 
   /// Identifier expressions.
   FailureOr<ast::Expr *> parseAttributeExpr();
-  FailureOr<ast::Expr *> parseDeclRefExpr(StringRef name, llvm::SMRange loc);
+  FailureOr<ast::Expr *> parseDeclRefExpr(StringRef name, SMRange loc);
   FailureOr<ast::Expr *> parseIdentifierExpr();
   FailureOr<ast::Expr *> parseMemberAccessExpr(ast::Expr *parentExpr);
   FailureOr<ast::OpNameDecl *> parseOperationName(bool allowEmptyName = false);
   FailureOr<ast::OpNameDecl *> parseWrappedOperationName(bool allowEmptyName);
   FailureOr<ast::Expr *> parseOperationExpr();
   FailureOr<ast::Expr *> parseTupleExpr();
   FailureOr<ast::Expr *> parseTypeExpr();
   FailureOr<ast::Expr *> parseUnderscoreExpr();
private:
   //===--------------------------------------------------------------------===//
 
   //===--------------------------------------------------------------------===//
   // Decls
 
   /// Try to create a pattern decl with the given components, returning the
   /// Pattern on success.
   FailureOr<ast::PatternDecl *>
-  createPatternDecl(llvm::SMRange loc, const ast::Name *name,
+  createPatternDecl(SMRange loc, const ast::Name *name,
                     const ParsedPatternMetadata &metadata,
                     ast::CompoundStmt *body);
 
   /// Try to create a variable decl with the given components, returning the
   /// Variable on success.
   FailureOr<ast::VariableDecl *>
-  createVariableDecl(StringRef name, llvm::SMRange loc, ast::Expr *initializer,
+  createVariableDecl(StringRef name, SMRange loc, ast::Expr *initializer,
                      ArrayRef<ast::ConstraintRef> constraints);
 
   /// Validate the constraints used to constraint a variable decl.
   /// `inferredType` is the type of the variable inferred by the constraints
   /// within the list, and is updated to the most refined type as determined by
   /// the constraints. Returns success if the constraint list is valid, failure
   /// otherwise.
   LogicalResult
   validateVariableConstraints(ArrayRef<ast::ConstraintRef> constraints,
                               ast::Type &inferredType);
   /// Validate a single reference to a constraint. `inferredType` contains the
   /// currently inferred variabled type and is refined within the type defined
   /// by the constraint. Returns success if the constraint is valid, failure
   /// otherwise.
   LogicalResult validateVariableConstraint(const ast::ConstraintRef &ref,
                                            ast::Type &inferredType);
   LogicalResult validateTypeConstraintExpr(const ast::Expr *typeExpr);
   LogicalResult validateTypeRangeConstraintExpr(const ast::Expr *typeExpr);
 
   //===--------------------------------------------------------------------===//
   // Exprs
 
-  FailureOr<ast::DeclRefExpr *> createDeclRefExpr(llvm::SMRange loc,
+  FailureOr<ast::DeclRefExpr *> createDeclRefExpr(SMRange loc,
                                                   ast::Decl *decl);
   FailureOr<ast::DeclRefExpr *>
-  createInlineVariableExpr(ast::Type type, StringRef name, llvm::SMRange loc,
+  createInlineVariableExpr(ast::Type type, StringRef name, SMRange loc,
                            ArrayRef<ast::ConstraintRef> constraints);
   FailureOr<ast::MemberAccessExpr *>
   createMemberAccessExpr(ast::Expr *parentExpr, StringRef name,
-                         llvm::SMRange loc);
+                         SMRange loc);
 
   /// Validate the member access `name` into the given parent expression. On
   /// success, this also returns the type of the member accessed.
   FailureOr<ast::Type> validateMemberAccess(ast::Expr *parentExpr,
-                                            StringRef name, llvm::SMRange loc);
+                                            StringRef name, SMRange loc);
   FailureOr<ast::OperationExpr *>
-  createOperationExpr(llvm::SMRange loc, const ast::OpNameDecl *name,
+  createOperationExpr(SMRange loc, const ast::OpNameDecl *name,
                       MutableArrayRef<ast::Expr *> operands,
                       MutableArrayRef<ast::NamedAttributeDecl *> attributes,
                       MutableArrayRef<ast::Expr *> results);
   LogicalResult
-  validateOperationOperands(llvm::SMRange loc, Optional<StringRef> name,
+  validateOperationOperands(SMRange loc, Optional<StringRef> name,
                             MutableArrayRef<ast::Expr *> operands);
-  LogicalResult validateOperationResults(llvm::SMRange loc,
+  LogicalResult validateOperationResults(SMRange loc,
                                          Optional<StringRef> name,
                                          MutableArrayRef<ast::Expr *> results);
   LogicalResult
-  validateOperationOperandsOrResults(llvm::SMRange loc,
+  validateOperationOperandsOrResults(SMRange loc,
                                      Optional<StringRef> name,
                                      MutableArrayRef<ast::Expr *> values,
                                      ast::Type singleTy, ast::Type rangeTy);
-  FailureOr<ast::TupleExpr *> createTupleExpr(llvm::SMRange loc,
+  FailureOr<ast::TupleExpr *> createTupleExpr(SMRange loc,
                                               ArrayRef<ast::Expr *> elements,
                                               ArrayRef<StringRef> elementNames);
 
   //===--------------------------------------------------------------------===//
   // Stmts
 
-  FailureOr<ast::EraseStmt *> createEraseStmt(llvm::SMRange loc,
+  FailureOr<ast::EraseStmt *> createEraseStmt(SMRange loc,
                                               ast::Expr *rootOp);
   FailureOr<ast::ReplaceStmt *>
-  createReplaceStmt(llvm::SMRange loc, ast::Expr *rootOp,
+  createReplaceStmt(SMRange loc, ast::Expr *rootOp,
                     MutableArrayRef<ast::Expr *> replValues);
   FailureOr<ast::RewriteStmt *>
-  createRewriteStmt(llvm::SMRange loc, ast::Expr *rootOp,
+  createRewriteStmt(SMRange loc, ast::Expr *rootOp,
                     ast::CompoundStmt *rewriteBody);
 
   //===--------------------------------------------------------------------===//
   // Lexer Utilities
   //===--------------------------------------------------------------------===//
 
   /// If the current token has the specified kind, consume it and return true.
   /// If not, return false.
private:
   /// current token is. This is preferred to the above method because it leads
   /// to more self-documenting code with better checking.
   void consumeToken(Token::Kind kind) {
     assert(curToken.is(kind) && "consumed an unexpected token");
     consumeToken();
   }
 
   /// Reset the lexer to the location at the given position.
-  void resetToken(llvm::SMRange tokLoc) {
+  void resetToken(SMRange tokLoc) {
     lexer.resetPointer(tokLoc.Start.getPointer());
     curToken = lexer.lexToken();
   }
 
   /// Consume the specified token if present and return success. On failure,
   /// output a diagnostic and return failure.
   LogicalResult parseToken(Token::Kind kind, const Twine &msg) {
     if (curToken.getKind() != kind)
       return emitError(curToken.getLoc(), msg);
     consumeToken();
     return success();
   }
-  LogicalResult emitError(llvm::SMRange loc, const Twine &msg) {
+  LogicalResult emitError(SMRange loc, const Twine &msg) {
     lexer.emitError(loc, msg);
     return failure();
   }
   LogicalResult emitError(const Twine &msg) {
     return emitError(curToken.getLoc(), msg);
   }
-  LogicalResult emitErrorAndNote(llvm::SMRange loc, const Twine &msg,
-                                 llvm::SMRange noteLoc, const Twine &note) {
+  LogicalResult emitErrorAndNote(SMRange loc, const Twine &msg,
+                                 SMRange noteLoc, const Twine &note) {
     lexer.emitErrorAndNote(loc, msg, noteLoc, note);
     return failure();
   }
 
   //===--------------------------------------------------------------------===//
   // Fields
   //===--------------------------------------------------------------------===//
 
private:
 
   /// Cached types to simplify verification and expression creation.
   ast::Type valueTy, valueRangeTy;
   ast::Type typeTy, typeRangeTy;
 };
 } // namespace
 
 FailureOr<ast::Module *> Parser::parseModule() {
-  llvm::SMLoc moduleLoc = curToken.getStartLoc();
+  SMLoc moduleLoc = curToken.getStartLoc();
   pushDeclScope();
 
   // Parse the top-level decls of the module.
   SmallVector<ast::Decl *> decls;
   if (failed(parseModuleBody(decls)))
     return popDeclScope(), failure();
 
   popDeclScope();
LogicalResult Parser::parseDirective(SmallVector<ast::Decl *> &decls) {
   StringRef directive = curToken.getSpelling();
   if (directive == "#include")
     return parseInclude(decls);
 
   return emitError("unknown directive `" + directive + "`");
 }
 
 LogicalResult Parser::parseInclude(SmallVector<ast::Decl *> &decls) {
-  llvm::SMRange loc = curToken.getLoc();
+  SMRange loc = curToken.getLoc();
   consumeToken(Token::directive);
 
   // Parse the file being included.
   if (!curToken.isString())
     return emitError(loc,
                      "expected string file name after `include` directive");
-  llvm::SMRange fileLoc = curToken.getLoc();
+  SMRange fileLoc = curToken.getLoc();
   std::string filenameStr = curToken.getStringValue();
   StringRef filename = filenameStr;
   consumeToken();
 
   // Check the type of include. If ending with `.pdll`, this is another pdl file
   // to be parsed along with the current module.
   if (filename.endswith(".pdll")) {
     if (failed(lexer.pushInclude(filename)))
if (consumeIf(Token::equal)) {
     // UnitAttr.
     attrValue = ast::AttributeExpr::create(ctx, name.getLoc(), "unit");
   }
 
   return ast::NamedAttributeDecl::create(ctx, name, attrValue);
 }
 
 FailureOr<ast::Decl *> Parser::parsePatternDecl() {
-  llvm::SMRange loc = curToken.getLoc();
+  SMRange loc = curToken.getLoc();
   consumeToken(Token::kw_Pattern);
   llvm::SaveAndRestore<ParserContext> saveCtx(parserContext,
                                               ParserContext::PatternMatch);
 
   // Check for an optional identifier for the pattern name.
   const ast::Name *name = nullptr;
   if (curToken.is(Token::identifier)) {
     name = &ast::Name::create(ctx, curToken.getSpelling(), curToken.getLoc());
return emitError((*std::next(bodyIt))->getLoc(),
                      "rewrite statement, but found trailing statements");
   }
 
   return createPatternDecl(loc, name, metadata, body);
 }
 
 LogicalResult
 Parser::parsePatternDeclMetadata(ParsedPatternMetadata &metadata) {
-  Optional<llvm::SMRange> benefitLoc;
-  Optional<llvm::SMRange> hasBoundedRecursionLoc;
+  Optional<SMRange> benefitLoc;
+  Optional<SMRange> hasBoundedRecursionLoc;
 
   do {
     if (curToken.isNot(Token::identifier))
       return emitError("expected pattern metadata identifier");
     StringRef metadataStr = curToken.getSpelling();
-    llvm::SMRange metadataLoc = curToken.getLoc();
+    SMRange metadataLoc = curToken.getLoc();
     consumeToken(Token::identifier);
 
     // Parse the benefit metadata: benefit(<integer-value>)
     if (metadataStr == "benefit") {
       if (benefitLoc) {
         return emitErrorAndNote(metadataLoc,
                                 "pattern benefit has already been specified",
                                 *benefitLoc, "see previous definition here");
if (ast::Decl *lastDecl = curDeclScope->lookup(name.getName())) {
     return emitErrorAndNote(
         name.getLoc(), "`" + name.getName() + "` has already been defined",
         lastDecl->getName()->getLoc(), "see previous definition here");
   }
   return success();
 }
 
 FailureOr<ast::VariableDecl *>
-Parser::defineVariableDecl(StringRef name, llvm::SMRange nameLoc,
+Parser::defineVariableDecl(StringRef name, SMRange nameLoc,
                            ast::Type type, ast::Expr *initExpr,
                            ArrayRef<ast::ConstraintRef> constraints) {
   assert(curDeclScope && "defining variable outside of decl scope");
   const ast::Name &nameDecl = ast::Name::create(ctx, name, nameLoc);
 
   // If the name of the variable indicates a special variable, we don't add it
   // to the scope. This variable is local to the definition point.
   if (name.empty() || name == "_") {
     return ast::VariableDecl::create(ctx, nameDecl, type, initExpr,
                                      constraints);
   }
   if (failed(checkDefineNamedDecl(nameDecl)))
     return failure();
 
   auto *varDecl =
       ast::VariableDecl::create(ctx, nameDecl, type, initExpr, constraints);
   curDeclScope->add(varDecl);
   return varDecl;
 }
 
 FailureOr<ast::VariableDecl *>
-Parser::defineVariableDecl(StringRef name, llvm::SMRange nameLoc,
+Parser::defineVariableDecl(StringRef name, SMRange nameLoc,
                            ast::Type type,
                            ArrayRef<ast::ConstraintRef> constraints) {
   return defineVariableDecl(name, nameLoc, type, /*initExpr=*/nullptr,
                             constraints);
 }
 
 LogicalResult Parser::parseVariableDeclConstraintList(
     SmallVectorImpl<ast::ConstraintRef> &constraints) {
-  Optional<llvm::SMRange> typeConstraint;
+  Optional<SMRange> typeConstraint;
   auto parseSingleConstraint = [&] {
     FailureOr<ast::ConstraintRef> constraint =
         parseConstraint(typeConstraint, constraints);
     if (failed(constraint))
       return failure();
     constraints.push_back(*constraint);
     return success();
   };
 
   // Check to see if this is a single constraint, or a list.
   if (!consumeIf(Token::l_square))
     return parseSingleConstraint();
 
   do {
     if (failed(parseSingleConstraint()))
       return failure();
   } while (consumeIf(Token::comma));
   return parseToken(Token::r_square, "expected `]` after constraint list");
 }
 
 FailureOr<ast::ConstraintRef>
-Parser::parseConstraint(Optional<llvm::SMRange> &typeConstraint,
+Parser::parseConstraint(Optional<SMRange> &typeConstraint,
                         ArrayRef<ast::ConstraintRef> existingConstraints) {
   auto parseTypeConstraint = [&](ast::Expr *&typeExpr) -> LogicalResult {
     if (typeConstraint)
       return emitErrorAndNote(
           curToken.getLoc(),
           "the type of this variable has already been constrained",
           *typeConstraint, "see previous constraint location here");
     FailureOr<ast::Expr *> constraintExpr = parseTypeConstraintExpr();
     if (failed(constraintExpr))
       return failure();
     typeExpr = *constraintExpr;
     typeConstraint = typeExpr->getLoc();
     return success();
   };
 
-  llvm::SMRange loc = curToken.getLoc();
+  SMRange loc = curToken.getLoc();
   switch (curToken.getKind()) {
   case Token::kw_Attr: {
     consumeToken(Token::kw_Attr);
 
     // Check for a type constraint.
     ast::Expr *typeExpr = nullptr;
     if (curToken.is(Token::less) && failed(parseTypeConstraint(typeExpr)))
       return failure();
default:
       return lhsExpr;
     }
     if (failed(lhsExpr))
       return failure();
   }
 }
 
 FailureOr<ast::Expr *> Parser::parseAttributeExpr() {
-  llvm::SMRange loc = curToken.getLoc();
+  SMRange loc = curToken.getLoc();
   consumeToken(Token::kw_attr);
 
   // If we aren't followed by a `<`, the `attr` keyword is treated as a normal
   // identifier.
   if (!consumeIf(Token::less)) {
     resetToken(loc);
     return parseIdentifierExpr();
   }
 
   if (!curToken.isString())
     return emitError("expected string literal containing MLIR attribute");
   std::string attrExpr = curToken.getStringValue();
   consumeToken();
 
   if (failed(
           parseToken(Token::greater, "expected `>` after attribute literal")))
     return failure();
   return ast::AttributeExpr::create(ctx, loc, attrExpr);
 }
 
 FailureOr<ast::Expr *> Parser::parseDeclRefExpr(StringRef name,
-                                                llvm::SMRange loc) {
+                                                SMRange loc) {
   ast::Decl *decl = curDeclScope->lookup(name);
   if (!decl)
     return emitError(loc, "undefined reference to `" + name + "`");
 
   return createDeclRefExpr(loc, decl);
 }
 
 FailureOr<ast::Expr *> Parser::parseIdentifierExpr() {
   StringRef name = curToken.getSpelling();
-  llvm::SMRange nameLoc = curToken.getLoc();
+  SMRange nameLoc = curToken.getLoc();
   consumeToken();
 
   // Check to see if this is a decl ref expression that defines a variable
   // inline.
   if (consumeIf(Token::colon)) {
     SmallVector<ast::ConstraintRef> constraints;
     if (failed(parseVariableDeclConstraintList(constraints)))
       return failure();
     ast::Type type;
     if (failed(validateVariableConstraints(constraints, type)))
       return failure();
     return createInlineVariableExpr(type, name, nameLoc, constraints);
   }
 
   return parseDeclRefExpr(name, nameLoc);
 }
 
 FailureOr<ast::Expr *> Parser::parseMemberAccessExpr(ast::Expr *parentExpr) {
-  llvm::SMRange loc = curToken.getLoc();
+  SMRange loc = curToken.getLoc();
   consumeToken(Token::dot);
 
   // Parse the member name.
   Token memberNameTok = curToken;
   if (memberNameTok.isNot(Token::identifier, Token::integer) &&
       !memberNameTok.isKeyword())
     return emitError(loc, "expected identifier or numeric member name");
   StringRef memberName = memberNameTok.getSpelling();
   consumeToken();
 
   return createMemberAccessExpr(parentExpr, memberName, loc);
 }
 
 FailureOr<ast::OpNameDecl *> Parser::parseOperationName(bool allowEmptyName) {
-  llvm::SMRange loc = curToken.getLoc();
+  SMRange loc = curToken.getLoc();
 
   // Handle the case of an no operation name.
   if (curToken.isNot(Token::identifier) && !curToken.isKeyword()) {
     if (allowEmptyName)
-      return ast::OpNameDecl::create(ctx, llvm::SMRange());
+      return ast::OpNameDecl::create(ctx, SMRange());
     return emitError("expected dialect namespace");
   }
   StringRef name = curToken.getSpelling();
   consumeToken();
 
   // Otherwise, this is a literal operation name.
   if (failed(parseToken(Token::dot, "expected `.` after dialect namespace")))
     return failure();
FailureOr<ast::OpNameDecl *> Parser::parseOperationName(bool allowEmptyName) {
   } while (curToken.isAny(Token::identifier, Token::dot) ||
            curToken.isKeyword());
   return ast::OpNameDecl::create(ctx, ast::Name::create(ctx, name, loc));
 }
 
 FailureOr<ast::OpNameDecl *>
 Parser::parseWrappedOperationName(bool allowEmptyName) {
   if (!consumeIf(Token::less))
-    return ast::OpNameDecl::create(ctx, llvm::SMRange());
+    return ast::OpNameDecl::create(ctx, SMRange());
 
   FailureOr<ast::OpNameDecl *> opNameDecl = parseOperationName(allowEmptyName);
   if (failed(opNameDecl))
     return failure();
 
   if (failed(parseToken(Token::greater, "expected `>` after operation name")))
     return failure();
   return opNameDecl;
 }
 
 FailureOr<ast::Expr *> Parser::parseOperationExpr() {
-  llvm::SMRange loc = curToken.getLoc();
+  SMRange loc = curToken.getLoc();
   consumeToken(Token::kw_op);
 
   // If it isn't followed by a `<`, the `op` keyword is treated as a normal
   // identifier.
   if (curToken.isNot(Token::less)) {
     resetToken(loc);
     return parseIdentifierExpr();
   }
if (failed(parseToken(Token::r_paren,
       return failure();
   }
 
   return createOperationExpr(loc, *opNameDecl, operands, attributes,
                              resultTypes);
 }
 
 FailureOr<ast::Expr *> Parser::parseTupleExpr() {
-  llvm::SMRange loc = curToken.getLoc();
+  SMRange loc = curToken.getLoc();
   consumeToken(Token::l_paren);
 
-  DenseMap<StringRef, llvm::SMRange> usedNames;
+  DenseMap<StringRef, SMRange> usedNames;
   SmallVector<StringRef> elementNames;
   SmallVector<ast::Expr *> elements;
   if (curToken.isNot(Token::r_paren)) {
     do {
       // Check for the optional element name assignment before the value.
       StringRef elementName;
       if (curToken.is(Token::identifier) || curToken.isDependentKeyword()) {
         Token elementNameTok = curToken;
FailureOr<ast::Expr *> Parser::parseTupleExpr() {
   loc.End = curToken.getEndLoc();
   if (failed(
           parseToken(Token::r_paren, "expected `)` after tuple element list")))
     return failure();
   return createTupleExpr(loc, elements, elementNames);
 }
 
 FailureOr<ast::Expr *> Parser::parseTypeExpr() {
-  llvm::SMRange loc = curToken.getLoc();
+  SMRange loc = curToken.getLoc();
   consumeToken(Token::kw_type);
 
   // If we aren't followed by a `<`, the `type` keyword is treated as a normal
   // identifier.
   if (!consumeIf(Token::less)) {
     resetToken(loc);
     return parseIdentifierExpr();
   }
 
   if (!curToken.isString())
     return emitError("expected string literal containing MLIR type");
   std::string attrExpr = curToken.getStringValue();
   consumeToken();
 
   if (failed(parseToken(Token::greater, "expected `>` after type literal")))
     return failure();
   return ast::TypeExpr::create(ctx, loc, attrExpr);
 }
 
 FailureOr<ast::Expr *> Parser::parseUnderscoreExpr() {
   StringRef name = curToken.getSpelling();
-  llvm::SMRange nameLoc = curToken.getLoc();
+  SMRange nameLoc = curToken.getLoc();
   consumeToken(Token::underscore);
 
   // Underscore expressions require a constraint list.
   if (failed(parseToken(Token::colon, "expected `:` after `_` variable")))
     return failure();
 
   // Parse the constraints for the expression.
   SmallVector<ast::ConstraintRef> constraints;
FailureOr<ast::Stmt *> Parser::parseStmt(bool expectTerminalSemicolon) {
   if (failed(stmt) ||
       (expectTerminalSemicolon &&
        failed(parseToken(Token::semicolon, "expected `;` after statement"))))
     return failure();
   return stmt;
 }
 
 FailureOr<ast::CompoundStmt *> Parser::parseCompoundStmt() {
-  llvm::SMLoc startLoc = curToken.getStartLoc();
+  SMLoc startLoc = curToken.getStartLoc();
   consumeToken(Token::l_brace);
 
   // Push a new block scope and parse any nested statements.
   pushDeclScope();
   SmallVector<ast::Stmt *> statements;
   while (curToken.isNot(Token::r_brace)) {
     FailureOr<ast::Stmt *> statement = parseStmt();
     if (failed(statement))
       return popDeclScope(), failure();
     statements.push_back(*statement);
   }
   popDeclScope();
 
   // Consume the end brace.
-  llvm::SMRange location(startLoc, curToken.getEndLoc());
+  SMRange location(startLoc, curToken.getEndLoc());
   consumeToken(Token::r_brace);
 
   return ast::CompoundStmt::create(ctx, location, statements);
 }
 
 FailureOr<ast::EraseStmt *> Parser::parseEraseStmt() {
-  llvm::SMRange loc = curToken.getLoc();
+  SMRange loc = curToken.getLoc();
   consumeToken(Token::kw_erase);
 
   // Parse the root operation expression.
   FailureOr<ast::Expr *> rootOp = parseExpr();
   if (failed(rootOp))
     return failure();
 
   return createEraseStmt(loc, *rootOp);
 }
 
 FailureOr<ast::LetStmt *> Parser::parseLetStmt() {
-  llvm::SMRange loc = curToken.getLoc();
+  SMRange loc = curToken.getLoc();
   consumeToken(Token::kw_let);
 
   // Parse the name of the new variable.
-  llvm::SMRange varLoc = curToken.getLoc();
+  SMRange varLoc = curToken.getLoc();
   if (curToken.isNot(Token::identifier) && !curToken.isDependentKeyword()) {
     // `_` is a reserved variable name.
     if (curToken.is(Token::underscore)) {
       return emitError(varLoc,
                        "`_` may only be used to define \"inline\" variables");
     }
     return emitError(varLoc,
                      "expected identifier after `let` to name a new variable");
FailureOr<ast::LetStmt *> Parser::parseLetStmt() {
   FailureOr<ast::VariableDecl *> varDecl =
       createVariableDecl(varName, varLoc, initializer, constraints);
   if (failed(varDecl))
     return failure();
   return ast::LetStmt::create(ctx, loc, *varDecl);
 }
 
 FailureOr<ast::ReplaceStmt *> Parser::parseReplaceStmt() {
-  llvm::SMRange loc = curToken.getLoc();
+  SMRange loc = curToken.getLoc();
   consumeToken(Token::kw_replace);
 
   // Parse the root operation expression.
   FailureOr<ast::Expr *> rootOp = parseExpr();
   if (failed(rootOp))
     return failure();
 
   if (failed(
if (failed(replExpr))
       return failure();
     replValues.emplace_back(*replExpr);
   }
 
   return createReplaceStmt(loc, *rootOp, replValues);
 }
 
 FailureOr<ast::RewriteStmt *> Parser::parseRewriteStmt() {
-  llvm::SMRange loc = curToken.getLoc();
+  SMRange loc = curToken.getLoc();
   consumeToken(Token::kw_rewrite);
 
   // Parse the root operation.
   FailureOr<ast::Expr *> rootOp = parseExpr();
   if (failed(rootOp))
     return failure();
 
   if (failed(parseToken(Token::kw_with, "expected `with` before rewrite body")))

 //===----------------------------------------------------------------------===//
 // Creation+Analysis
 //===----------------------------------------------------------------------===//
 
 //===----------------------------------------------------------------------===//
 // Decls
 
 FailureOr<ast::PatternDecl *>
-Parser::createPatternDecl(llvm::SMRange loc, const ast::Name *name,
+Parser::createPatternDecl(SMRange loc, const ast::Name *name,
                           const ParsedPatternMetadata &metadata,
                           ast::CompoundStmt *body) {
   return ast::PatternDecl::create(ctx, loc, name, metadata.benefit,
                                   metadata.hasBoundedRecursion, body);
 }
 
 FailureOr<ast::VariableDecl *>
-Parser::createVariableDecl(StringRef name, llvm::SMRange loc,
+Parser::createVariableDecl(StringRef name, SMRange loc,
                            ast::Expr *initializer,
                            ArrayRef<ast::ConstraintRef> constraints) {
   // The type of the variable, which is expected to be inferred by either a
   // constraint or an initializer expression.
   ast::Type type;
   if (failed(validateVariableConstraints(constraints, type)))
     return failure();
 
return emitError(typeExpr->getLoc(),
                      "expected expression of `TypeRange` in type constraint");
   }
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Exprs
 
-FailureOr<ast::DeclRefExpr *> Parser::createDeclRefExpr(llvm::SMRange loc,
+FailureOr<ast::DeclRefExpr *> Parser::createDeclRefExpr(SMRange loc,
                                                         ast::Decl *decl) {
   // Check the type of decl being referenced.
   ast::Type declType;
   if (auto *varDecl = dyn_cast<ast::VariableDecl>(decl))
     declType = varDecl->getType();
   else
     return emitError(loc, "invalid reference to `" +
                               decl->getName()->getName() + "`");
 
   return ast::DeclRefExpr::create(ctx, loc, decl, declType);
 }
 
 FailureOr<ast::DeclRefExpr *>
 Parser::createInlineVariableExpr(ast::Type type, StringRef name,
-                                 llvm::SMRange loc,
+                                 SMRange loc,
                                  ArrayRef<ast::ConstraintRef> constraints) {
   FailureOr<ast::VariableDecl *> decl =
       defineVariableDecl(name, loc, type, constraints);
   if (failed(decl))
     return failure();
   return ast::DeclRefExpr::create(ctx, loc, *decl, type);
 }
 
 FailureOr<ast::MemberAccessExpr *>
 Parser::createMemberAccessExpr(ast::Expr *parentExpr, StringRef name,
-                               llvm::SMRange loc) {
+                               SMRange loc) {
   // Validate the member name for the given parent expression.
   FailureOr<ast::Type> memberType = validateMemberAccess(parentExpr, name, loc);
   if (failed(memberType))
     return failure();
 
   return ast::MemberAccessExpr::create(ctx, loc, parentExpr, name, *memberType);
 }
 
 FailureOr<ast::Type> Parser::validateMemberAccess(ast::Expr *parentExpr,
                                                   StringRef name,
-                                                  llvm::SMRange loc) {
+                                                  SMRange loc) {
   ast::Type parentType = parentExpr->getType();
   if (parentType.isa<ast::OperationType>()) {
     if (name == ast::AllResultsMemberAccessExpr::getMemberName())
       return valueRangeTy;
   } else if (auto tupleType = parentType.dyn_cast<ast::TupleType>()) {
     // Handle indexed results.
     unsigned index = 0;
     if (llvm::isDigit(name[0]) && !name.getAsInteger(/*Radix=*/10, index) &&
FailureOr<ast::Type> Parser::validateMemberAccess(ast::Expr *parentExpr,
   }
   return emitError(
       loc,
       llvm::formatv("invalid member access `{0}` on expression of type `{1}`",
                     name, parentType));
 }
 
 FailureOr<ast::OperationExpr *> Parser::createOperationExpr(
-    llvm::SMRange loc, const ast::OpNameDecl *name,
+    SMRange loc, const ast::OpNameDecl *name,
     MutableArrayRef<ast::Expr *> operands,
     MutableArrayRef<ast::NamedAttributeDecl *> attributes,
     MutableArrayRef<ast::Expr *> results) {
   Optional<StringRef> opNameRef = name->getName();
 
   // Verify the inputs operands.
   if (failed(validateOperationOperands(loc, opNameRef, operands)))
     return failure();
FailureOr<ast::OperationExpr *> Parser::createOperationExpr(
   if (failed(validateOperationResults(loc, opNameRef, results)))
     return failure();
 
   return ast::OperationExpr::create(ctx, loc, name, operands, results,
                                     attributes);
 }
 
 LogicalResult
-Parser::validateOperationOperands(llvm::SMRange loc, Optional<StringRef> name,
+Parser::validateOperationOperands(SMRange loc, Optional<StringRef> name,
                                   MutableArrayRef<ast::Expr *> operands) {
   return validateOperationOperandsOrResults(loc, name, operands, valueTy,
                                             valueRangeTy);
 }
 
 LogicalResult
-Parser::validateOperationResults(llvm::SMRange loc, Optional<StringRef> name,
+Parser::validateOperationResults(SMRange loc, Optional<StringRef> name,
                                  MutableArrayRef<ast::Expr *> results) {
   return validateOperationOperandsOrResults(loc, name, results, typeTy,
                                             typeRangeTy);
 }
 
 LogicalResult Parser::validateOperationOperandsOrResults(
-    llvm::SMRange loc, Optional<StringRef> name,
+    SMRange loc, Optional<StringRef> name,
     MutableArrayRef<ast::Expr *> values, ast::Type singleTy,
     ast::Type rangeTy) {
   // All operation types accept a single range parameter.
   if (values.size() == 1) {
     if (failed(convertExpressionTo(values[0], rangeTy)))
       return failure();
     return success();
   }
return emitError(
         llvm::formatv(
             "expected `{0}` or `{1}` convertible expression, but got `{2}`",
             singleTy, rangeTy, valueExprType));
   }
   return success();
 }
 
 FailureOr<ast::TupleExpr *>
-Parser::createTupleExpr(llvm::SMRange loc, ArrayRef<ast::Expr *> elements,
+Parser::createTupleExpr(SMRange loc, ArrayRef<ast::Expr *> elements,
                         ArrayRef<StringRef> elementNames) {
   for (const ast::Expr *element : elements) {
     ast::Type eleTy = element->getType();
     if (eleTy.isa<ast::ConstraintType, ast::TupleType>()) {
       return emitError(
           element->getLoc(),
           llvm::formatv("unable to build a tuple with `{0}` element", eleTy));
     }
   }
   return ast::TupleExpr::create(ctx, loc, elements, elementNames);
 }
 
 //===----------------------------------------------------------------------===//
 // Stmts
 
-FailureOr<ast::EraseStmt *> Parser::createEraseStmt(llvm::SMRange loc,
+FailureOr<ast::EraseStmt *> Parser::createEraseStmt(SMRange loc,
                                                     ast::Expr *rootOp) {
   // Check that root is an Operation.
   ast::Type rootType = rootOp->getType();
   if (!rootType.isa<ast::OperationType>())
     return emitError(rootOp->getLoc(), "expected `Op` expression");
 
   return ast::EraseStmt::create(ctx, loc, rootOp);
 }
 
 FailureOr<ast::ReplaceStmt *>
-Parser::createReplaceStmt(llvm::SMRange loc, ast::Expr *rootOp,
+Parser::createReplaceStmt(SMRange loc, ast::Expr *rootOp,
                           MutableArrayRef<ast::Expr *> replValues) {
   // Check that root is an Operation.
   ast::Type rootType = rootOp->getType();
   if (!rootType.isa<ast::OperationType>()) {
     return emitError(
         rootOp->getLoc(),
         llvm::formatv("expected `Op` expression, but got `{0}`", rootType));
   }
if (replType != valueTy && replType != valueRangeTy) {
                                      replType));
     }
   }
 
   return ast::ReplaceStmt::create(ctx, loc, rootOp, replValues);
 }
 
 FailureOr<ast::RewriteStmt *>
-Parser::createRewriteStmt(llvm::SMRange loc, ast::Expr *rootOp,
+Parser::createRewriteStmt(SMRange loc, ast::Expr *rootOp,
                           ast::CompoundStmt *rewriteBody) {
   // Check that root is an Operation.
   ast::Type rootType = rootOp->getType();
   if (!rootType.isa<ast::OperationType>()) {
     return emitError(
         rootOp->getLoc(),
         llvm::formatv("expected `Op` expression, but got `{0}`", rootType));
   }

mlir/lib/Tools/mlir-lsp-server/MLIRServer.cpp

 #include "mlir/IR/Operation.h"
 #include "mlir/Parser.h"
 #include "mlir/Parser/AsmParserState.h"
 #include "llvm/Support/SourceMgr.h"
 
 using namespace mlir;
 
 /// Returns a language server position for the given source location.
-static lsp::Position getPosFromLoc(llvm::SourceMgr &mgr, llvm::SMLoc loc) {
+static lsp::Position getPosFromLoc(llvm::SourceMgr &mgr, SMLoc loc) {
   std::pair<unsigned, unsigned> lineAndCol = mgr.getLineAndColumn(loc);
   lsp::Position pos;
   pos.line = lineAndCol.first - 1;
   pos.character = lineAndCol.second - 1;
   return pos;
 }
 
 /// Returns a source location from the given language server position.
-static llvm::SMLoc getPosFromLoc(llvm::SourceMgr &mgr, lsp::Position pos) {
+static SMLoc getPosFromLoc(llvm::SourceMgr &mgr, lsp::Position pos) {
   return mgr.FindLocForLineAndColumn(mgr.getMainFileID(), pos.line + 1,
                                      pos.character);
 }
 
 /// Returns a language server range for the given source range.
-static lsp::Range getRangeFromLoc(llvm::SourceMgr &mgr, llvm::SMRange range) {
+static lsp::Range getRangeFromLoc(llvm::SourceMgr &mgr, SMRange range) {
   return {getPosFromLoc(mgr, range.Start), getPosFromLoc(mgr, range.End)};
 }
 
 /// Returns a language server location from the given source range.
 static lsp::Location getLocationFromLoc(llvm::SourceMgr &mgr,
-                                        llvm::SMRange range,
+                                        SMRange range,
                                         const lsp::URIForFile &uri) {
   return lsp::Location{uri, getRangeFromLoc(mgr, range)};
 }
 
 /// Returns a language server location from the given MLIR file location.
 static Optional<lsp::Location> getLocationFromLoc(FileLineColLoc loc) {
   llvm::Expected<lsp::URIForFile> sourceURI =
       lsp::URIForFile::fromFile(loc.getFilename());
getLocationFromLoc(llvm::SourceMgr &sourceMgr, Location loc,
   loc->walk([&](Location nestedLoc) {
     FileLineColLoc fileLoc = nestedLoc.dyn_cast<FileLineColLoc>();
     if (!fileLoc)
       return WalkResult::advance();
 
     Optional<lsp::Location> sourceLoc = getLocationFromLoc(fileLoc);
     if (sourceLoc && (!uri || sourceLoc->uri == *uri)) {
       location = *sourceLoc;
-      llvm::SMLoc loc = sourceMgr.FindLocForLineAndColumn(
+      SMLoc loc = sourceMgr.FindLocForLineAndColumn(
           sourceMgr.getMainFileID(), fileLoc.getLine(), fileLoc.getColumn());
 
       // Use range of potential identifier starting at location, else length 1
       // range.
       location->range.end.character += 1;
-      if (Optional<llvm::SMRange> range =
+      if (Optional<SMRange> range =
               AsmParserState::convertIdLocToRange(loc)) {
         auto lineCol = sourceMgr.getLineAndColumn(range->End);
         location->range.end.character =
             std::max(fileLoc.getColumn() + 1, lineCol.second - 1);
       }
       return WalkResult::interrupt();
     }
     return WalkResult::advance();
if (sourceLoc && sourceLoc->uri != uri)
       locations.push_back(*sourceLoc);
     return WalkResult::advance();
   });
 }
 
 /// Returns true if the given range contains the given source location. Note
 /// that this has slightly different behavior than SMRange because it is
 /// inclusive of the end location.
-static bool contains(llvm::SMRange range, llvm::SMLoc loc) {
+static bool contains(SMRange range, SMLoc loc) {
   return range.Start.getPointer() <= loc.getPointer() &&
          loc.getPointer() <= range.End.getPointer();
 }
 
 /// Returns true if the given location is contained by the definition or one of
 /// the uses of the given SMDefinition. If provided, `overlappedRange` is set to
 /// the range within `def` that the provided `loc` overlapped with.
-static bool isDefOrUse(const AsmParserState::SMDefinition &def, llvm::SMLoc loc,
-                       llvm::SMRange *overlappedRange = nullptr) {
+static bool isDefOrUse(const AsmParserState::SMDefinition &def, SMLoc loc,
+                       SMRange *overlappedRange = nullptr) {
   // Check the main definition.
   if (contains(def.loc, loc)) {
     if (overlappedRange)
       *overlappedRange = def.loc;
     return true;
   }
 
   // Check the uses.
-  const auto *useIt = llvm::find_if(def.uses, [&](const llvm::SMRange &range) {
+  const auto *useIt = llvm::find_if(def.uses, [&](const SMRange &range) {
     return contains(range, loc);
   });
   if (useIt != def.uses.end()) {
     if (overlappedRange)
       *overlappedRange = *useIt;
     return true;
   }
   return false;
 }
 
 /// Given a location pointing to a result, return the result number it refers
 /// to or None if it refers to all of the results.
-static Optional<unsigned> getResultNumberFromLoc(llvm::SMLoc loc) {
+static Optional<unsigned> getResultNumberFromLoc(SMLoc loc) {
   // Skip all of the identifier characters.
   auto isIdentifierChar = [](char c) {
     return isalnum(c) || c == '%' || c == '$' || c == '.' || c == '_' ||
            c == '-';
   };
   const char *curPtr = loc.getPointer();
   while (isIdentifierChar(*curPtr))
     ++curPtr;
static Optional<unsigned> getResultNumberFromLoc(SMLoc loc) {
   StringRef numberStr(numberStart, curPtr - numberStart);
   unsigned resultNumber = 0;
   return numberStr.consumeInteger(10, resultNumber) ? Optional<unsigned>()
                                                     : resultNumber;
 }
 
 /// Given a source location range, return the text covered by the given range.
 /// If the range is invalid, returns None.
-static Optional<StringRef> getTextFromRange(llvm::SMRange range) {
+static Optional<StringRef> getTextFromRange(SMRange range) {
   if (!range.isValid())
     return None;
   const char *startPtr = range.Start.getPointer();
   return StringRef(startPtr, range.End.getPointer() - startPtr);
 }
 
 /// Given a block, return its position in its parent region.
 static unsigned getBlockNumber(Block *block) {
   return std::distance(block->getParent()->begin(), block->getIterator());
 }
 
 /// Given a block and source location, print the source name of the block to the
 /// given output stream.
 static void printDefBlockName(raw_ostream &os, Block *block,
-                              llvm::SMRange loc = {}) {
+                              SMRange loc = {}) {
   // Try to extract a name from the source location.
   Optional<StringRef> text = getTextFromRange(loc);
   if (text && text->startswith("^")) {
     os << *text;
     return;
   }
 
   // Otherwise, we don't have a name so print the block number.
struct MLIRDocument {
 
   //===--------------------------------------------------------------------===//
   // Hover
   //===--------------------------------------------------------------------===//
 
   Optional<lsp::Hover> findHover(const lsp::URIForFile &uri,
                                  const lsp::Position &hoverPos);
   Optional<lsp::Hover>
-  buildHoverForOperation(llvm::SMRange hoverRange,
+  buildHoverForOperation(SMRange hoverRange,
                          const AsmParserState::OperationDefinition &op);
-  lsp::Hover buildHoverForOperationResult(llvm::SMRange hoverRange,
+  lsp::Hover buildHoverForOperationResult(SMRange hoverRange,
                                           Operation *op, unsigned resultStart,
                                           unsigned resultEnd,
-                                          llvm::SMLoc posLoc);
-  lsp::Hover buildHoverForBlock(llvm::SMRange hoverRange,
+                                          SMLoc posLoc);
+  lsp::Hover buildHoverForBlock(SMRange hoverRange,
                                 const AsmParserState::BlockDefinition &block);
   lsp::Hover
-  buildHoverForBlockArgument(llvm::SMRange hoverRange, BlockArgument arg,
+  buildHoverForBlockArgument(SMRange hoverRange, BlockArgument arg,
                              const AsmParserState::BlockDefinition &block);
 
   //===--------------------------------------------------------------------===//
   // Document Symbols
   //===--------------------------------------------------------------------===//
 
   void findDocumentSymbols(std::vector<lsp::DocumentSymbol> &symbols);
   void findDocumentSymbols(Operation *op,
MLIRDocument::MLIRDocument(MLIRContext &context, const lsp::URIForFile &uri,
 
   // Try to parsed the given IR string.
   auto memBuffer = llvm::MemoryBuffer::getMemBufferCopy(contents, uri.file());
   if (!memBuffer) {
     lsp::Logger::error("Failed to create memory buffer for file", uri.file());
     return;
   }
 
-  sourceMgr.AddNewSourceBuffer(std::move(memBuffer), llvm::SMLoc());
+  sourceMgr.AddNewSourceBuffer(std::move(memBuffer), SMLoc());
   if (failed(parseSourceFile(sourceMgr, &parsedIR, &context, nullptr,
                              &asmState))) {
     // If parsing failed, clear out any of the current state.
     parsedIR.clear();
     asmState = AsmParserState();
     return;
   }
 }
 
 //===----------------------------------------------------------------------===//
 // MLIRDocument: Definitions and References
 //===----------------------------------------------------------------------===//
 
 void MLIRDocument::getLocationsOf(const lsp::URIForFile &uri,
                                   const lsp::Position &defPos,
                                   std::vector<lsp::Location> &locations) {
-  llvm::SMLoc posLoc = getPosFromLoc(sourceMgr, defPos);
+  SMLoc posLoc = getPosFromLoc(sourceMgr, defPos);
 
   // Functor used to check if an SM definition contains the position.
   auto containsPosition = [&](const AsmParserState::SMDefinition &def) {
     if (!isDefOrUse(def, posLoc))
       return false;
     locations.push_back(getLocationFromLoc(sourceMgr, def.loc, uri));
     return true;
   };

 
 void MLIRDocument::findReferencesOf(const lsp::URIForFile &uri,
                                     const lsp::Position &pos,
                                     std::vector<lsp::Location> &references) {
   // Functor used to append all of the definitions/uses of the given SM
   // definition to the reference list.
   auto appendSMDef = [&](const AsmParserState::SMDefinition &def) {
     references.push_back(getLocationFromLoc(sourceMgr, def.loc, uri));
-    for (const llvm::SMRange &use : def.uses)
+    for (const SMRange &use : def.uses)
       references.push_back(getLocationFromLoc(sourceMgr, use, uri));
   };
 
-  llvm::SMLoc posLoc = getPosFromLoc(sourceMgr, pos);
+  SMLoc posLoc = getPosFromLoc(sourceMgr, pos);
 
   // Check all definitions related to operations.
   for (const AsmParserState::OperationDefinition &op : asmState.getOpDefs()) {
     if (contains(op.loc, posLoc)) {
       for (const auto &result : op.resultGroups)
         appendSMDef(result.definition);
       for (const auto &symUse : op.symbolUses)
         if (contains(symUse, posLoc))

 }
 
 //===----------------------------------------------------------------------===//
 // MLIRDocument: Hover
 //===----------------------------------------------------------------------===//
 
 Optional<lsp::Hover> MLIRDocument::findHover(const lsp::URIForFile &uri,
                                              const lsp::Position &hoverPos) {
-  llvm::SMLoc posLoc = getPosFromLoc(sourceMgr, hoverPos);
-  llvm::SMRange hoverRange;
+  SMLoc posLoc = getPosFromLoc(sourceMgr, hoverPos);
+  SMRange hoverRange;
 
   // Check for Hovers on operations and results.
   for (const AsmParserState::OperationDefinition &op : asmState.getOpDefs()) {
     // Check if the position points at this operation.
     if (contains(op.loc, posLoc))
       return buildHoverForOperation(op.loc, op);
 
     // Check if the position points at the symbol name.
for (const auto &arg : llvm::enumerate(block.arguments)) {
       return buildHoverForBlockArgument(
           hoverRange, block.block->getArgument(arg.index()), block);
     }
   }
   return llvm::None;
 }
 
 Optional<lsp::Hover> MLIRDocument::buildHoverForOperation(
-    llvm::SMRange hoverRange, const AsmParserState::OperationDefinition &op) {
+    SMRange hoverRange, const AsmParserState::OperationDefinition &op) {
   lsp::Hover hover(getRangeFromLoc(sourceMgr, hoverRange));
   llvm::raw_string_ostream os(hover.contents.value);
 
   // Add the operation name to the hover.
   os << "\"" << op.op->getName() << "\"";
   if (SymbolOpInterface symbol = dyn_cast<SymbolOpInterface>(op.op))
     os << " : " << symbol.getVisibility() << " @" << symbol.getName() << "";
   os << "\n\n";
Optional<lsp::Hover> MLIRDocument::buildHoverForOperation(
 
   // Move the regions back to the current operation.
   for (Region &region : op.op->getRegions())
     region.takeBody(*regions.back());
 
   return hover;
 }
 
-lsp::Hover MLIRDocument::buildHoverForOperationResult(llvm::SMRange hoverRange,
+lsp::Hover MLIRDocument::buildHoverForOperationResult(SMRange hoverRange,
                                                       Operation *op,
                                                       unsigned resultStart,
                                                       unsigned resultEnd,
-                                                      llvm::SMLoc posLoc) {
+                                                      SMLoc posLoc) {
   lsp::Hover hover(getRangeFromLoc(sourceMgr, hoverRange));
   llvm::raw_string_ostream os(hover.contents.value);
 
   // Add the parent operation name to the hover.
   os << "Operation: \"" << op->getName() << "\"\n\n";
 
   // Check to see if the location points to a specific result within the
   // group.
llvm::interleaveComma(
         op->getResults().slice(resultStart, resultEnd), os,
         [&](Value result) { os << "`" << result.getType() << "`"; });
   }
 
   return hover;
 }
 
 lsp::Hover
-MLIRDocument::buildHoverForBlock(llvm::SMRange hoverRange,
+MLIRDocument::buildHoverForBlock(SMRange hoverRange,
                                  const AsmParserState::BlockDefinition &block) {
   lsp::Hover hover(getRangeFromLoc(sourceMgr, hoverRange));
   llvm::raw_string_ostream os(hover.contents.value);
 
   // Print the given block to the hover output stream.
   auto printBlockToHover = [&](Block *newBlock) {
     if (const auto *def = asmState.getBlockDef(newBlock))
       printDefBlockName(os, *def);
if (!block.block->hasNoSuccessors()) {
     llvm::interleaveComma(block.block->getSuccessors(), os, printBlockToHover);
     os << "\n\n";
   }
 
   return hover;
 }
 
 lsp::Hover MLIRDocument::buildHoverForBlockArgument(
-    llvm::SMRange hoverRange, BlockArgument arg,
+    SMRange hoverRange, BlockArgument arg,
     const AsmParserState::BlockDefinition &block) {
   lsp::Hover hover(getRangeFromLoc(sourceMgr, hoverRange));
   llvm::raw_string_ostream os(hover.contents.value);
 
   // Display the parent operation, block, the argument number, and the type.
   os << "Operation: \"" << block.block->getParentOp()->getName() << "\"\n\n"
      << "Block: ";
   printDefBlockName(os, block);

mlir/lib/Translation/Translation.cpp

LogicalResult mlir::mlirTranslateMain(int argc, char **argv,
   }
 
   // Processes the memory buffer with a new MLIRContext.
   auto processBuffer = [&](std::unique_ptr<llvm::MemoryBuffer> ownedBuffer,
                            raw_ostream &os) {
     MLIRContext context;
     context.printOpOnDiagnostic(!verifyDiagnostics);
     llvm::SourceMgr sourceMgr;
-    sourceMgr.AddNewSourceBuffer(std::move(ownedBuffer), llvm::SMLoc());
+    sourceMgr.AddNewSourceBuffer(std::move(ownedBuffer), SMLoc());
 
     if (!verifyDiagnostics) {
       SourceMgrDiagnosticHandler sourceMgrHandler(sourceMgr, &context);
       return (*translationRequested)(sourceMgr, os, &context);
     }
 
     // In the diagnostic verification flow, we ignore whether the translation
     // failed (in most cases, it is expected to fail). Instead, we check if the

mlir/test/lib/Dialect/Test/TestDialect.cpp

 // Test PrettyPrintedRegionOp -  exercising the following parser APIs
 //   parseGenericOperationAfterOpName
 //   parseCustomOperationName
 //===----------------------------------------------------------------------===//
 
 static ParseResult parsePrettyPrintedRegionOp(OpAsmParser &parser,
                                               OperationState &result) {
 
-  llvm::SMLoc loc = parser.getCurrentLocation();
+  SMLoc loc = parser.getCurrentLocation();
   Location currLocation = parser.getEncodedSourceLoc(loc);
 
   // Parse the operands.
   SmallVector<OpAsmParser::OperandType, 2> operands;
   if (parser.parseOperandList(operands))
     return failure();
 
   // Check if we are parsing the pretty-printed version

mlir/tools/mlir-pdll/mlir-pdll.cpp

enum class OutputType {
   AST,
 };
 
 static LogicalResult
 processBuffer(raw_ostream &os, std::unique_ptr<llvm::MemoryBuffer> chunkBuffer,
               OutputType outputType, std::vector<std::string> &includeDirs) {
   llvm::SourceMgr sourceMgr;
   sourceMgr.setIncludeDirs(includeDirs);
-  sourceMgr.AddNewSourceBuffer(std::move(chunkBuffer), llvm::SMLoc());
+  sourceMgr.AddNewSourceBuffer(std::move(chunkBuffer), SMLoc());
 
   ast::Context astContext;
   FailureOr<ast::Module *> module = parsePDLAST(astContext, sourceMgr);
   if (failed(module))
     return failure();
 
   switch (outputType) {
   case OutputType::AST:

mlir/tools/mlir-tblgen/AttrOrTypeFormatGen.cpp

 // Interface
 //===----------------------------------------------------------------------===//
 
 void mlir::tblgen::generateAttrOrTypeFormat(const AttrOrTypeDef &def,
                                             MethodBody &parser,
                                             MethodBody &printer) {
   llvm::SourceMgr mgr;
   mgr.AddNewSourceBuffer(
       llvm::MemoryBuffer::getMemBuffer(*def.getAssemblyFormat()),
-      llvm::SMLoc());
+      SMLoc());
 
   /// Parse the custom assembly format>
   FormatParser fmtParser(mgr, def);
   FailureOr<AttrOrTypeFormat> format = fmtParser.parse();
   if (failed(format)) {
     if (formatErrorIsFatal)
       PrintFatalError(def.getLoc(), "failed to parse assembly format");
     return;
   }
 
   /// Generate the parser and printer.
   format->genParser(parser);
   format->genPrinter(printer);
 }

mlir/tools/mlir-tblgen/FormatGen.h

public:
 
   /// Return the bytes that make up this token.
   StringRef getSpelling() const { return spelling; }
 
   /// Return the kind of this token.
   Kind getKind() const { return kind; }
 
   /// Return a location for this token.
-  llvm::SMLoc getLoc() const;
+  SMLoc getLoc() const;
 
   /// Return if this token is a keyword.
   bool isKeyword() const {
     return getKind() > Kind::keyword_start && getKind() < Kind::keyword_end;
   }
 
 private:
   /// Discriminator that indicates the kind of token this is.
   Kind kind;
 
   /// A reference to the entire token contents; this is always a pointer into
   /// a memory buffer owned by the source manager.
   StringRef spelling;
 };
 
 //===----------------------------------------------------------------------===//
 // FormatLexer
 //===----------------------------------------------------------------------===//
 
 /// This class implements a simple lexer for operation assembly format strings.
 class FormatLexer {
 public:
-  FormatLexer(llvm::SourceMgr &mgr, llvm::SMLoc loc);
+  FormatLexer(llvm::SourceMgr &mgr, SMLoc loc);
 
   /// Lex the next token and return it.
   FormatToken lexToken();
 
   /// Emit an error to the lexer with the given location and message.
-  FormatToken emitError(llvm::SMLoc loc, const Twine &msg);
+  FormatToken emitError(SMLoc loc, const Twine &msg);
   FormatToken emitError(const char *loc, const Twine &msg);
 
-  FormatToken emitErrorAndNote(llvm::SMLoc loc, const Twine &msg,
+  FormatToken emitErrorAndNote(SMLoc loc, const Twine &msg,
                                const Twine &note);
 
 private:
   /// Return the next character in the stream.
   int getNextChar();
 
   /// Lex an identifier, literal, or variable.
   FormatToken lexIdentifier(const char *tokStart);
   FormatToken lexLiteral(const char *tokStart);
   FormatToken lexVariable(const char *tokStart);
 
   /// Create a token with the current pointer and a start pointer.
   FormatToken formToken(FormatToken::Kind kind, const char *tokStart) {
     return FormatToken(kind, StringRef(tokStart, curPtr - tokStart));
   }
 
   /// The source manager containing the format string.
   llvm::SourceMgr &mgr;
   /// Location of the format string.
-  llvm::SMLoc loc;
+  SMLoc loc;
   /// Buffer containing the format string.
   StringRef curBuffer;
   /// Current pointer in the buffer.
   const char *curPtr;
 };
 
 /// Whether a space needs to be emitted before a literal. E.g., two keywords
 /// back-to-back require a space separator, but a keyword followed by '<' does

mlir/tools/mlir-tblgen/FormatGen.cpp

 
 using namespace mlir;
 using namespace mlir::tblgen;
 
 //===----------------------------------------------------------------------===//
 // FormatToken
 //===----------------------------------------------------------------------===//
 
-llvm::SMLoc FormatToken::getLoc() const {
-  return llvm::SMLoc::getFromPointer(spelling.data());
+SMLoc FormatToken::getLoc() const {
+  return SMLoc::getFromPointer(spelling.data());
 }
 
 //===----------------------------------------------------------------------===//
 // FormatLexer
 //===----------------------------------------------------------------------===//
 
-FormatLexer::FormatLexer(llvm::SourceMgr &mgr, llvm::SMLoc loc)
+FormatLexer::FormatLexer(llvm::SourceMgr &mgr, SMLoc loc)
     : mgr(mgr), loc(loc),
       curBuffer(mgr.getMemoryBuffer(mgr.getMainFileID())->getBuffer()),
       curPtr(curBuffer.begin()) {}
 
-FormatToken FormatLexer::emitError(llvm::SMLoc loc, const Twine &msg) {
+FormatToken FormatLexer::emitError(SMLoc loc, const Twine &msg) {
   mgr.PrintMessage(loc, llvm::SourceMgr::DK_Error, msg);
   llvm::SrcMgr.PrintMessage(this->loc, llvm::SourceMgr::DK_Note,
                             "in custom assembly format for this operation");
   return formToken(FormatToken::error, loc.getPointer());
 }
 
 FormatToken FormatLexer::emitError(const char *loc, const Twine &msg) {
-  return emitError(llvm::SMLoc::getFromPointer(loc), msg);
+  return emitError(SMLoc::getFromPointer(loc), msg);
 }
 
-FormatToken FormatLexer::emitErrorAndNote(llvm::SMLoc loc, const Twine &msg,
+FormatToken FormatLexer::emitErrorAndNote(SMLoc loc, const Twine &msg,
                                           const Twine &note) {
   mgr.PrintMessage(loc, llvm::SourceMgr::DK_Error, msg);
   llvm::SrcMgr.PrintMessage(this->loc, llvm::SourceMgr::DK_Note,
                             "in custom assembly format for this operation");
   mgr.PrintMessage(loc, llvm::SourceMgr::DK_Note, note);
   return formToken(FormatToken::error, loc.getPointer());
 }
 

mlir/tools/mlir-tblgen/OpFormatGen.cpp

struct TypeResolutionInstance {
     Optional<StringRef> transformer;
   };
 
   /// An iterator over the elements of a format group.
   using ElementsIterT = llvm::pointee_iterator<
       std::vector<std::unique_ptr<Element>>::const_iterator>;
 
   /// Verify the state of operation attributes within the format.
-  LogicalResult verifyAttributes(llvm::SMLoc loc);
+  LogicalResult verifyAttributes(SMLoc loc);
   /// Verify the attribute elements at the back of the given stack of iterators.
   LogicalResult verifyAttributes(
-      llvm::SMLoc loc,
+      SMLoc loc,
       SmallVectorImpl<std::pair<ElementsIterT, ElementsIterT>> &iteratorStack);
 
   /// Verify the state of operation operands within the format.
   LogicalResult
-  verifyOperands(llvm::SMLoc loc,
+  verifyOperands(SMLoc loc,
                  llvm::StringMap<TypeResolutionInstance> &variableTyResolver);
 
   /// Verify the state of operation regions within the format.
-  LogicalResult verifyRegions(llvm::SMLoc loc);
+  LogicalResult verifyRegions(SMLoc loc);
 
   /// Verify the state of operation results within the format.
   LogicalResult
-  verifyResults(llvm::SMLoc loc,
+  verifyResults(SMLoc loc,
                 llvm::StringMap<TypeResolutionInstance> &variableTyResolver);
 
   /// Verify the state of operation successors within the format.
-  LogicalResult verifySuccessors(llvm::SMLoc loc);
+  LogicalResult verifySuccessors(SMLoc loc);
 
   /// Given the values of an `AllTypesMatch` trait, check for inferable type
   /// resolution.
   void handleAllTypesMatchConstraint(
       ArrayRef<StringRef> values,
       llvm::StringMap<TypeResolutionInstance> &variableTyResolver);
   /// Check for inferable type resolution given all operands, and or results,
   /// have the same type. If 'includeResults' is true, the results also have the
LogicalResult parseDirective(std::unique_ptr<Element> &element,
                                ParserContext context);
   LogicalResult parseLiteral(std::unique_ptr<Element> &element,
                              ParserContext context);
   LogicalResult parseOptional(std::unique_ptr<Element> &element,
                               ParserContext context);
   LogicalResult parseOptionalChildElement(
       std::vector<std::unique_ptr<Element>> &childElements,
       Optional<unsigned> &anchorIdx);
   LogicalResult verifyOptionalChildElement(Element *element,
-                                           llvm::SMLoc childLoc, bool isAnchor);
+                                           SMLoc childLoc, bool isAnchor);
 
   /// Parse the various different directives.
   LogicalResult parseAttrDictDirective(std::unique_ptr<Element> &element,
-                                       llvm::SMLoc loc, ParserContext context,
+                                       SMLoc loc, ParserContext context,
                                        bool withKeyword);
   LogicalResult parseCustomDirective(std::unique_ptr<Element> &element,
-                                     llvm::SMLoc loc, ParserContext context);
+                                     SMLoc loc, ParserContext context);
   LogicalResult parseCustomDirectiveParameter(
       std::vector<std::unique_ptr<Element>> &parameters);
   LogicalResult parseFunctionalTypeDirective(std::unique_ptr<Element> &element,
                                              FormatToken tok,
                                              ParserContext context);
   LogicalResult parseOperandsDirective(std::unique_ptr<Element> &element,
-                                       llvm::SMLoc loc, ParserContext context);
+                                       SMLoc loc, ParserContext context);
   LogicalResult parseQualifiedDirective(std::unique_ptr<Element> &element,
                                         FormatToken tok, ParserContext context);
   LogicalResult parseReferenceDirective(std::unique_ptr<Element> &element,
-                                        llvm::SMLoc loc, ParserContext context);
+                                        SMLoc loc, ParserContext context);
   LogicalResult parseRegionsDirective(std::unique_ptr<Element> &element,
-                                      llvm::SMLoc loc, ParserContext context);
+                                      SMLoc loc, ParserContext context);
   LogicalResult parseResultsDirective(std::unique_ptr<Element> &element,
-                                      llvm::SMLoc loc, ParserContext context);
+                                      SMLoc loc, ParserContext context);
   LogicalResult parseSuccessorsDirective(std::unique_ptr<Element> &element,
-                                         llvm::SMLoc loc,
+                                         SMLoc loc,
                                          ParserContext context);
   LogicalResult parseTypeDirective(std::unique_ptr<Element> &element,
                                    FormatToken tok, ParserContext context);
   LogicalResult parseTypeDirectiveOperand(std::unique_ptr<Element> &element,
                                           bool isRefChild = false);
 
   //===--------------------------------------------------------------------===//
   // Lexer Utilities
   //===--------------------------------------------------------------------===//
 
   /// Advance the current lexer onto the next token.
   void consumeToken() {
     assert(curToken.getKind() != FormatToken::eof &&
            curToken.getKind() != FormatToken::error &&
            "shouldn't advance past EOF or errors");
     curToken = lexer.lexToken();
   }
   LogicalResult parseToken(FormatToken::Kind kind, const Twine &msg) {
     if (curToken.getKind() != kind)
       return emitError(curToken.getLoc(), msg);
     consumeToken();
     return ::mlir::success();
   }
-  LogicalResult emitError(llvm::SMLoc loc, const Twine &msg) {
+  LogicalResult emitError(SMLoc loc, const Twine &msg) {
     lexer.emitError(loc, msg);
     return ::mlir::failure();
   }
-  LogicalResult emitErrorAndNote(llvm::SMLoc loc, const Twine &msg,
+  LogicalResult emitErrorAndNote(SMLoc loc, const Twine &msg,
                                  const Twine &note) {
     lexer.emitErrorAndNote(loc, msg, note);
     return ::mlir::failure();
   }
 
   //===--------------------------------------------------------------------===//
   // Fields
   //===--------------------------------------------------------------------===//
private:
   llvm::SmallSetVector<const NamedAttribute *, 8> seenAttrs;
   llvm::DenseSet<const NamedTypeConstraint *> seenOperands;
   llvm::DenseSet<const NamedRegion *> seenRegions;
   llvm::DenseSet<const NamedSuccessor *> seenSuccessors;
 };
 } // namespace
 
 LogicalResult FormatParser::parse() {
-  llvm::SMLoc loc = curToken.getLoc();
+  SMLoc loc = curToken.getLoc();
 
   // Parse each of the format elements into the main format.
   while (curToken.getKind() != FormatToken::eof) {
     std::unique_ptr<Element> element;
     if (failed(parseElement(element, TopLevelContext)))
       return ::mlir::failure();
     fmt.elements.push_back(std::move(element));
   }
if (failed(verifyAttributes(loc)) ||
       failed(verifyRegions(loc)) || failed(verifySuccessors(loc)))
     return ::mlir::failure();
 
   // Collect the set of used attributes in the format.
   fmt.usedAttributes = seenAttrs.takeVector();
   return ::mlir::success();
 }
 
-LogicalResult FormatParser::verifyAttributes(llvm::SMLoc loc) {
+LogicalResult FormatParser::verifyAttributes(SMLoc loc) {
   // Check that there are no `:` literals after an attribute without a constant
   // type. The attribute grammar contains an optional trailing colon type, which
   // can lead to unexpected and generally unintended behavior. Given that, it is
   // better to just error out here instead.
   using ElementsIterT = llvm::pointee_iterator<
       std::vector<std::unique_ptr<Element>>::const_iterator>;
   SmallVector<std::pair<ElementsIterT, ElementsIterT>, 1> iteratorStack;
   iteratorStack.emplace_back(fmt.elements.begin(), fmt.elements.end());
if (var->constraint.isVariadicOfVariadic()) {
           var->constraint.getVariadicOfVariadicSegmentSizeAttr());
     }
   }
 
   return ::mlir::success();
 }
 /// Verify the attribute elements at the back of the given stack of iterators.
 LogicalResult FormatParser::verifyAttributes(
-    llvm::SMLoc loc,
+    SMLoc loc,
     SmallVectorImpl<std::pair<ElementsIterT, ElementsIterT>> &iteratorStack) {
   auto &stackIt = iteratorStack.back();
   ElementsIterT &it = stackIt.first, e = stackIt.second;
   while (it != e) {
     Element *element = &*(it++);
 
     // Traverse into optional groups.
     if (auto *optional = dyn_cast<OptionalElement>(element)) {
for (auto &nextItPair : iteratorStack) {
       }
     }
   }
   iteratorStack.pop_back();
   return ::mlir::success();
 }
 
 LogicalResult FormatParser::verifyOperands(
-    llvm::SMLoc loc,
+    SMLoc loc,
     llvm::StringMap<TypeResolutionInstance> &variableTyResolver) {
   // Check that all of the operands are within the format, and their types can
   // be inferred.
   auto &buildableTypes = fmt.buildableTypes;
   for (unsigned i = 0, e = op.getNumOperands(); i != e; ++i) {
     NamedTypeConstraint &operand = op.getOperand(i);
 
     // Check that the operand itself is in the format.
if (!builder || (fmt.allOperands && operand.isVariableLength())) {
               operand.name + ")' directive to the " + "custom assembly format");
     }
     auto it = buildableTypes.insert({*builder, buildableTypes.size()});
     fmt.operandTypes[i].setBuilderIdx(it.first->second);
   }
   return ::mlir::success();
 }
 
-LogicalResult FormatParser::verifyRegions(llvm::SMLoc loc) {
+LogicalResult FormatParser::verifyRegions(SMLoc loc) {
   // Check that all of the regions are within the format.
   if (hasAllRegions)
     return ::mlir::success();
 
   for (unsigned i = 0, e = op.getNumRegions(); i != e; ++i) {
     const NamedRegion &region = op.getRegion(i);
     if (!seenRegions.count(&region)) {
       return emitErrorAndNote(loc,
                               "region #" + Twine(i) + ", named '" +
                                   region.name + "', not found",
                               "suggest adding a '$" + region.name +
                                   "' directive to the custom assembly format");
     }
   }
   return ::mlir::success();
 }
 
 LogicalResult FormatParser::verifyResults(
-    llvm::SMLoc loc,
+    SMLoc loc,
     llvm::StringMap<TypeResolutionInstance> &variableTyResolver) {
   // If we format all of the types together, there is nothing to check.
   if (fmt.allResultTypes)
     return ::mlir::success();
 
   // If no result types are specified and we can infer them, infer all result
   // types
   if (op.getNumResults() > 0 && seenResultTypes.count() == 0 &&
for (unsigned i = 0, e = op.getNumResults(); i != e; ++i) {
     }
     // Note in the format that this result uses the custom builder.
     auto it = buildableTypes.insert({*builder, buildableTypes.size()});
     fmt.resultTypes[i].setBuilderIdx(it.first->second);
   }
   return ::mlir::success();
 }
 
-LogicalResult FormatParser::verifySuccessors(llvm::SMLoc loc) {
+LogicalResult FormatParser::verifySuccessors(SMLoc loc) {
   // Check that all of the successors are within the format.
   if (hasAllSuccessors)
     return ::mlir::success();
 
   for (unsigned i = 0, e = op.getNumSuccessors(); i != e; ++i) {
     const NamedSuccessor &successor = op.getSuccessor(i);
     if (!seenSuccessors.count(&successor)) {
       return emitErrorAndNote(loc,

 }
 
 LogicalResult FormatParser::parseVariable(std::unique_ptr<Element> &element,
                                           ParserContext context) {
   FormatToken varTok = curToken;
   consumeToken();
 
   StringRef name = varTok.getSpelling().drop_front();
-  llvm::SMLoc loc = varTok.getLoc();
+  SMLoc loc = varTok.getLoc();
 
   // Check that the parsed argument is something actually registered on the
   // op.
   /// Attributes
   if (const NamedAttribute *attr = findArg(op.getAttributes(), name)) {
     if (context == TypeDirectiveContext)
       return emitError(
           loc, "attributes cannot be used as children to a `type` directive");
if (!isValidLiteral(value, [&](Twine diag) {
       }))
     return failure();
   element = std::make_unique<LiteralElement>(value);
   return ::mlir::success();
 }
 
 LogicalResult FormatParser::parseOptional(std::unique_ptr<Element> &element,
                                           ParserContext context) {
-  llvm::SMLoc curLoc = curToken.getLoc();
+  SMLoc curLoc = curToken.getLoc();
   if (context != TopLevelContext)
     return emitError(curLoc, "optional groups can only be used as top-level "
                              "elements");
   consumeToken();
 
   // Parse the child elements for this optional group.
   std::vector<std::unique_ptr<Element>> thenElements, elseElements;
   Optional<unsigned> anchorIdx;
   do {
     if (failed(parseOptionalChildElement(thenElements, anchorIdx)))
       return ::mlir::failure();
   } while (curToken.getKind() != FormatToken::r_paren);
   consumeToken();
 
   // Parse the `else` elements of this optional group.
   if (curToken.getKind() == FormatToken::colon) {
     consumeToken();
     if (failed(parseToken(FormatToken::l_paren,
                           "expected '(' to start else branch "
                           "of optional group")))
       return failure();
     do {
-      llvm::SMLoc childLoc = curToken.getLoc();
+      SMLoc childLoc = curToken.getLoc();
       elseElements.push_back({});
       if (failed(parseElement(elseElements.back(), TopLevelContext)) ||
           failed(verifyOptionalChildElement(elseElements.back().get(), childLoc,
                                             /*isAnchor=*/false)))
         return failure();
     } while (curToken.getKind() != FormatToken::r_paren);
     consumeToken();
   }
LogicalResult FormatParser::parseOptional(std::unique_ptr<Element> &element,
   element = std::make_unique<OptionalElement>(
       std::move(thenElements), std::move(elseElements), *anchorIdx, parseStart);
   return ::mlir::success();
 }
 
 LogicalResult FormatParser::parseOptionalChildElement(
     std::vector<std::unique_ptr<Element>> &childElements,
     Optional<unsigned> &anchorIdx) {
-  llvm::SMLoc childLoc = curToken.getLoc();
+  SMLoc childLoc = curToken.getLoc();
   childElements.push_back({});
   if (failed(parseElement(childElements.back(), TopLevelContext)))
     return ::mlir::failure();
 
   // Check to see if this element is the anchor of the optional group.
   bool isAnchor = curToken.getKind() == FormatToken::caret;
   if (isAnchor) {
     if (anchorIdx)
       return emitError(childLoc, "only one element can be marked as the anchor "
                                  "of an optional group");
     anchorIdx = childElements.size() - 1;
     consumeToken();
   }
 
   return verifyOptionalChildElement(childElements.back().get(), childLoc,
                                     isAnchor);
 }
 
 LogicalResult FormatParser::verifyOptionalChildElement(Element *element,
-                                                       llvm::SMLoc childLoc,
+                                                       SMLoc childLoc,
                                                        bool isAnchor) {
   return TypeSwitch<Element *, LogicalResult>(element)
       // All attributes can be within the optional group, but only optional
       // attributes can be the anchor.
       .Case([&](AttributeVariable *attrEle) {
         if (isAnchor && !attrEle->getVar()->attr.isOptional())
           return emitError(childLoc, "only optional attributes can be used to "
                                      "anchor an optional group");
return TypeSwitch<Element *, LogicalResult>(element)
       .Default([&](Element *) {
         return emitError(childLoc, "only literals, types, and variables can be "
                                    "used within an optional group");
       });
 }
 
 LogicalResult
 FormatParser::parseAttrDictDirective(std::unique_ptr<Element> &element,
-                                     llvm::SMLoc loc, ParserContext context,
+                                     SMLoc loc, ParserContext context,
                                      bool withKeyword) {
   if (context == TypeDirectiveContext)
     return emitError(loc, "'attr-dict' directive can only be used as a "
                           "top-level directive");
 
   if (context == RefDirectiveContext) {
     if (!hasAttrDict)
       return emitError(loc, "'ref' of 'attr-dict' is not bound by a prior "
                             "'attr-dict' directive");
 
     // Otherwise, this is a top-level context.
   } else {
     if (hasAttrDict)
       return emitError(loc, "'attr-dict' directive has already been seen");
     hasAttrDict = true;
   }
 
   element = std::make_unique<AttrDictDirective>(withKeyword);
   return ::mlir::success();
 }
 
 LogicalResult
 FormatParser::parseCustomDirective(std::unique_ptr<Element> &element,
-                                   llvm::SMLoc loc, ParserContext context) {
-  llvm::SMLoc curLoc = curToken.getLoc();
+                                   SMLoc loc, ParserContext context) {
+  SMLoc curLoc = curToken.getLoc();
   if (context != TopLevelContext)
     return emitError(loc, "'custom' is only valid as a top-level directive");
 
   // Parse the custom directive name.
   if (failed(parseToken(FormatToken::less,
                         "expected '<' before custom directive name")))
     return ::mlir::failure();
 
FormatParser::parseCustomDirective(std::unique_ptr<Element> &element,
 
   element = std::make_unique<CustomDirective>(nameTok.getSpelling(),
                                               std::move(elements));
   return ::mlir::success();
 }
 
 LogicalResult FormatParser::parseCustomDirectiveParameter(
     std::vector<std::unique_ptr<Element>> &parameters) {
-  llvm::SMLoc childLoc = curToken.getLoc();
+  SMLoc childLoc = curToken.getLoc();
   parameters.push_back({});
   if (failed(parseElement(parameters.back(), CustomDirectiveContext)))
     return ::mlir::failure();
 
   // Verify that the element can be placed within a custom directive.
   if (!isa<RefDirective, TypeDirective, AttrDictDirective, AttributeVariable,
            OperandVariable, RegionVariable, SuccessorVariable>(
           parameters.back().get())) {
     return emitError(childLoc, "only variables and types may be used as "
                                "parameters to a custom directive");
   }
   return ::mlir::success();
 }
 
 LogicalResult FormatParser::parseFunctionalTypeDirective(
     std::unique_ptr<Element> &element, FormatToken tok, ParserContext context) {
-  llvm::SMLoc loc = tok.getLoc();
+  SMLoc loc = tok.getLoc();
   if (context != TopLevelContext)
     return emitError(
         loc, "'functional-type' is only valid as a top-level directive");
 
   // Parse the main operand.
   std::unique_ptr<Element> inputs, results;
   if (failed(parseToken(FormatToken::l_paren,
                         "expected '(' before argument list")) ||
       failed(parseTypeDirectiveOperand(inputs)) ||
       failed(parseToken(FormatToken::comma,
                         "expected ',' after inputs argument")) ||
       failed(parseTypeDirectiveOperand(results)) ||
       failed(
           parseToken(FormatToken::r_paren, "expected ')' after argument list")))
     return ::mlir::failure();
   element = std::make_unique<FunctionalTypeDirective>(std::move(inputs),
                                                       std::move(results));
   return ::mlir::success();
 }
 
 LogicalResult
 FormatParser::parseOperandsDirective(std::unique_ptr<Element> &element,
-                                     llvm::SMLoc loc, ParserContext context) {
+                                     SMLoc loc, ParserContext context) {
   if (context == RefDirectiveContext) {
     if (!fmt.allOperands)
       return emitError(loc, "'ref' of 'operands' is not bound by a prior "
                             "'operands' directive");
 
   } else if (context == TopLevelContext || context == CustomDirectiveContext) {
     if (fmt.allOperands || !seenOperands.empty())
       return emitError(loc, "'operands' directive creates overlap in format");
     fmt.allOperands = true;
   }
   element = std::make_unique<OperandsDirective>();
   return ::mlir::success();
 }
 
 LogicalResult
 FormatParser::parseReferenceDirective(std::unique_ptr<Element> &element,
-                                      llvm::SMLoc loc, ParserContext context) {
+                                      SMLoc loc, ParserContext context) {
   if (context != CustomDirectiveContext)
     return emitError(loc, "'ref' is only valid within a `custom` directive");
 
   std::unique_ptr<Element> operand;
   if (failed(parseToken(FormatToken::l_paren,
                         "expected '(' before argument list")) ||
       failed(parseElement(operand, RefDirectiveContext)) ||
       failed(
           parseToken(FormatToken::r_paren, "expected ')' after argument list")))
     return ::mlir::failure();
 
   element = std::make_unique<RefDirective>(std::move(operand));
   return ::mlir::success();
 }
 
 LogicalResult
 FormatParser::parseRegionsDirective(std::unique_ptr<Element> &element,
-                                    llvm::SMLoc loc, ParserContext context) {
+                                    SMLoc loc, ParserContext context) {
   if (context == TypeDirectiveContext)
     return emitError(loc, "'regions' is only valid as a top-level directive");
   if (context == RefDirectiveContext) {
     if (!hasAllRegions)
       return emitError(loc, "'ref' of 'regions' is not bound by a prior "
                             "'regions' directive");
 
     // Otherwise, this is a TopLevel directive.
   } else {
     if (hasAllRegions || !seenRegions.empty())
       return emitError(loc, "'regions' directive creates overlap in format");
     hasAllRegions = true;
   }
   element = std::make_unique<RegionsDirective>();
   return ::mlir::success();
 }
 
 LogicalResult
 FormatParser::parseResultsDirective(std::unique_ptr<Element> &element,
-                                    llvm::SMLoc loc, ParserContext context) {
+                                    SMLoc loc, ParserContext context) {
   if (context != TypeDirectiveContext)
     return emitError(loc, "'results' directive can can only be used as a child "
                           "to a 'type' directive");
   element = std::make_unique<ResultsDirective>();
   return ::mlir::success();
 }
 
 LogicalResult
 FormatParser::parseSuccessorsDirective(std::unique_ptr<Element> &element,
-                                       llvm::SMLoc loc, ParserContext context) {
+                                       SMLoc loc, ParserContext context) {
   if (context == TypeDirectiveContext)
     return emitError(loc,
                      "'successors' is only valid as a top-level directive");
   if (context == RefDirectiveContext) {
     if (!hasAllSuccessors)
       return emitError(loc, "'ref' of 'successors' is not bound by a prior "
                             "'successors' directive");
 
     // Otherwise, this is a TopLevel directive.
   } else {
     if (hasAllSuccessors || !seenSuccessors.empty())
       return emitError(loc, "'successors' directive creates overlap in format");
     hasAllSuccessors = true;
   }
   element = std::make_unique<SuccessorsDirective>();
   return ::mlir::success();
 }
 
 LogicalResult
 FormatParser::parseTypeDirective(std::unique_ptr<Element> &element,
                                  FormatToken tok, ParserContext context) {
-  llvm::SMLoc loc = tok.getLoc();
+  SMLoc loc = tok.getLoc();
   if (context == TypeDirectiveContext)
     return emitError(loc, "'type' cannot be used as a child of another `type`");
 
   bool isRefChild = context == RefDirectiveContext;
   std::unique_ptr<Element> operand;
   if (failed(parseToken(FormatToken::l_paren,
                         "expected '(' before argument list")) ||
       failed(parseTypeDirectiveOperand(operand, isRefChild)) ||
return emitError(
         "'qualified' directive expects an attribute or a `type` directive");
   }
   return success();
 }
 
 LogicalResult
 FormatParser::parseTypeDirectiveOperand(std::unique_ptr<Element> &element,
                                         bool isRefChild) {
-  llvm::SMLoc loc = curToken.getLoc();
+  SMLoc loc = curToken.getLoc();
   if (failed(parseElement(element, TypeDirectiveContext)))
     return ::mlir::failure();
   if (isa<LiteralElement>(element.get()))
     return emitError(
         loc, "'type' directive operand expects variable or directive operand");
 
   if (auto *var = dyn_cast<OperandVariable>(element.get())) {
     unsigned opIdx = var->getVar() - op.operand_begin();
void mlir::tblgen::generateOpFormat(const Operator &constOp, OpClass &opClass) {
   // the const interface.
   Operator &op = const_cast<Operator &>(constOp);
   if (!op.hasAssemblyFormat())
     return;
 
   // Parse the format description.
   llvm::SourceMgr mgr;
   mgr.AddNewSourceBuffer(
-      llvm::MemoryBuffer::getMemBuffer(op.getAssemblyFormat()), llvm::SMLoc());
+      llvm::MemoryBuffer::getMemBuffer(op.getAssemblyFormat()), SMLoc());
   OperationFormat format(op);
   if (failed(FormatParser(mgr, format, op).parse())) {
     // Exit the process if format errors are treated as fatal.
     if (formatErrorIsFatal) {
       // Invoke the interrupt handlers to run the file cleanup handlers.
       llvm::sys::RunInterruptHandlers();
       std::exit(1);
     }
     return;
   }
 
   // Generate the printer and parser based on the parsed format.
   format.genParser(op, opClass);
   format.genPrinter(op, opClass);
 }

mlir/tools/mlir-tblgen/RewriterGen.cpp

private:
 
   // Returns how many static values the given DAG `node` correspond to.
   int getNodeValueCount(DagNode node);
 
 private:
   // Pattern instantiation location followed by the location of multiclass
   // prototypes used. This is intended to be used as a whole to
   // PrintFatalError() on errors.
-  ArrayRef<llvm::SMLoc> loc;
+  ArrayRef<SMLoc> loc;
 
   // Op's TableGen Record to wrapper object.
   RecordOperatorMap *opMap;
 
   // Handy wrapper for pattern being emitted.
   Pattern pattern;
 
   // Map for all bound symbols' info.

mlir/unittests/Dialect/SparseTensor/MergerTest.cpp

 #include "mlir/Dialect/SparseTensor/Utils/Merger.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include <memory>
 
+using namespace mlir;
 using namespace mlir::sparse_tensor;
 
 namespace {
 
 /// Simple recursive data structure used to match expressions in Mergers.
 struct Pattern {
   Kind kind;