Introduce the notion of dialect attributes and dependent attributes. A dialect attribute derives its context from a specific dialect, whereas a dependent attribute derives context from what it is attached to. Following this, we now enforce that functions and function arguments may only contain dialect specific attributes. These are generic entities and cannot provide any specific context for a dependent attribute.

Dialect attributes are defined as:

        dialect-namespace `.` attr-name `:` attribute-value

Dialects can override any of the following hooks to verify the validity of a given attribute:
  * verifyFunctionAttribute
  * verifyFunctionArgAttribute
  * verifyInstructionAttribute

PiperOrigin-RevId: 236507970

Author: River707

mlir/g3doc/LangRef.md

@@ -867,14 +867,48 @@ Syntax:
 ``` {.ebnf}
 attribute-dict ::= `{` `}`
                  | `{` attribute-entry (`,` attribute-entry)* `}`
-attribute-entry ::= `:`? bare-id `:` attribute-value
+attribute-entry ::= dialect-attribute-entry | dependent-attribute-entry
+dialect-attribute-entry ::= dialect-namespace `.` bare-id `:` attribute-value
+dependent-attribute-entry ::= dependent-attribute-name `:` attribute-value
+dependent-attribute-name ::= (letter|[_]) (letter|digit|[_$])*
 ```
 
 Attributes are the mechanism for specifying constant data in MLIR in places
 where a variable is never allowed - e.g. the index of a
-[`dim` operation](#'dim'-operation), or the stride of a convolution.
+[`dim` operation](#'dim'-operation), or the stride of a convolution. They
+consist of a name and a [concrete attribute value](#attribute-values). It is
+possible to attach attributes to operations, functions, and function arguments.
+The set of expected attributes, their structure, and their interpretation are
+all contextually dependent on what they are attached to.
 
-Attributes have a name, and their values are represented by the following forms:
+There are two main classes of attributes; dependent and dialect. Dependent
+attributes derive their structure and meaning from what they are attached to,
+e.g the meaning of the `index` attribute on a `dim` operation is defined by the
+`dim` operation. Dialect attributes, on the other hand, derive their context and
+meaning from a specific dialect. An example of a dialect attribute may be a
+`swift.self` function argument attribute that indicates an argument is the
+self/context parameter. The context of this attribute is defined by the `swift`
+dialect and not the function argument.
+
+### Function and Argument Attributes
+
+Functions and function arguments in MLIR may have optional attributes attached
+to them. The sole constraint for these attributes is that they must be dialect
+specific attributes. This is because functions, and function arguments, are a
+generic entities and thus cannot apply any meaningful context necessary for
+dependent attributes. This has the added benefit of avoiding collisions between
+common attribute names, such as `noalias`.
+
+### Operation Attributes
+
+Operations, unlike functions and function arguments, may include both dialect
+specific and dependent attributes. This is because an operation represents a
+distinct semantic context, and can thus provide a single source of meaning to
+dependent attributes.
+
+### Attribute Values {#attribute-values}
+
+Attributes values are represented by the following forms:
 
 ``` {.ebnf}
 attribute-value ::= affine-map-attribute
@@ -889,11 +923,7 @@ attribute-value ::= affine-map-attribute
                   | type-attribute
 ```
 
-It is possible to attach attributes to instructions and functions, and the set
-of expected attributes, their structure, and the definition of that meaning is
-contextually dependent on the operation they are attached to.
-
-### AffineMap Attribute {#affine-map-attribute}
+#### AffineMap Attribute {#affine-map-attribute}
 
 Syntax:
 
@@ -903,7 +933,7 @@ affine-map-attribute ::= affine-map
 
 An affine-map attribute is an attribute that represents a affine-map object.
 
-### Array Attribute {#array-attribute}
+#### Array Attribute {#array-attribute}
 
 Syntax:
 
@@ -914,7 +944,7 @@ array-attribute ::= `[` (attribute-value (`,` attribute-value)*)? `]`
 An array attribute is an attribute that represents a collection of attribute
 values.
 
-### Boolean Attribute {#bool-attribute}
+#### Boolean Attribute {#bool-attribute}
 
 Syntax:
 
@@ -925,7 +955,7 @@ bool-attribute ::= bool-literal
 A boolean attribute is a literal attribute that represents a one-bit boolean
 value, true or false.
 
-### Elements Attributes {#elements-attributes}
+#### Elements Attributes {#elements-attributes}
 
 Syntax:
 
@@ -939,7 +969,7 @@ elements-attribute ::= dense-elements-attribute
 An elements attribute is a literal attribute that represents a constant
 [vector](#vector-type) or [tensor](#tensor-type) value.
 
-#### Dense Elements Attribute {#dense-elements-attribute}
+##### Dense Elements Attribute {#dense-elements-attribute}
 
 Syntax:
 
@@ -953,7 +983,7 @@ constant vector or tensor value has been packed to the element bitwidth. The
 element type of the vector or tensor constant must be of integer, index, or
 floating point type.
 
-#### Opaque Elements Attribute {#opaque-elements-attribute}
+##### Opaque Elements Attribute {#opaque-elements-attribute}
 
 Syntax:
 
@@ -970,7 +1000,7 @@ it.
 
 Note: The parsed string literal must be in hexadecimal form.
 
-#### Sparse Elements Attribute {#sparse-elements-attribute}
+##### Sparse Elements Attribute {#sparse-elements-attribute}
 
 Syntax:
 
@@ -1000,7 +1030,7 @@ Example:
 ///   [0, 0, 0, 0]]
 ```
 
-#### Splat Elements Attribute {#splat-elements-attribute}
+##### Splat Elements Attribute {#splat-elements-attribute}
 
 Syntax:
 
@@ -1012,7 +1042,7 @@ splat-elements-attribute ::= `splat` `<` ( tensor-type | vector-type ) `,`
 A splat elements attribute is an elements attribute that represents a tensor or
 vector constant where all elements have the same value.
 
-### Integer Attribute {#integer-attribute}
+#### Integer Attribute {#integer-attribute}
 
 Syntax:
 
@@ -1024,7 +1054,7 @@ An integer attribute is a literal attribute that represents an integral value of
 the specified integer or index type. The default type for this attribute, if one
 is not specified, is a 64-bit integer.
 
-### Integer Set Attribute {#integer-set-attribute}
+#### Integer Set Attribute {#integer-set-attribute}
 
 Syntax:
 
@@ -1034,7 +1064,7 @@ integer-set-attribute ::= affine-map
 
 An integer-set attribute is an attribute that represents a integer-set object.
 
-### Float Attribute {#float-attribute}
+#### Float Attribute {#float-attribute}
 
 Syntax:
 
@@ -1045,7 +1075,7 @@ float-attribute ::= float-literal (`:` float-type)?
 A float attribute is a literal attribute that represents a floating point value
 of the specified [float type](#floating-point-types).
 
-### Function Attribute {#function-attribute}
+#### Function Attribute {#function-attribute}
 
 Syntax:
 
@@ -1056,7 +1086,7 @@ function-attribute ::= function-id `:` function-type
 A function attribute is a literal attribute that represents a reference to the
 given function object.
 
-### String Attribute {#string-attribute}
+#### String Attribute {#string-attribute}
 
 Syntax:
 
@@ -1066,7 +1096,7 @@ string-attribute ::= string-literal
 
 A string attribute is an attribute that represents a string literal value.
 
-### Type Attribute {#type-attribute}
+#### Type Attribute {#type-attribute}
 
 Syntax:
 

mlir/include/mlir/IR/Dialect.h

@@ -101,6 +101,26 @@ class Dialect {
   virtual void
   getTypeAliases(SmallVectorImpl<std::pair<StringRef, Type>> &aliases) {}
 
+  /// Verify an attribute from this dialect on the given function. Returns true
+  /// if the verification failed, false otherwise.
+  virtual bool verifyFunctionAttribute(const Function *, Attribute) {
+    return false;
+  }
+
+  /// Verify an attribute from this dialect on the argument at 'argIndex' for
+  /// the given function. Returns true if the verification failed, false
+  /// otherwise.
+  virtual bool verifyFunctionArgAttribute(const Function *, unsigned argIndex,
+                                          Attribute) {
+    return false;
+  }
+
+  /// Verify an attribute from this dialect on the given instruction. Returns
+  /// true if the verification failed, false otherwise.
+  virtual bool verifyInstructionAttribute(const Instruction *, Attribute) {
+    return false;
+  }
+
   virtual ~Dialect();
 
   /// Utility function that returns if the given string is a valid dialect

mlir/lib/Analysis/Verifier.cpp

@@ -35,6 +35,7 @@
 
 #include "mlir/Analysis/Dominance.h"
 #include "mlir/IR/Attributes.h"
+#include "mlir/IR/Dialect.h"
 #include "mlir/IR/Function.h"
 #include "mlir/IR/Instruction.h"
 #include "mlir/IR/Module.h"
@@ -68,6 +69,15 @@ class FuncVerifier {
     return failure(message, fn);
   }
 
+  /// Returns the registered dialect for a dialect-specific attribute.
+  template <typename ErrorContext>
+  Dialect *getDialectForAttribute(const NamedAttribute &attr,
+                                  const ErrorContext &ctx) {
+    assert(attr.first.strref().contains('.') && "expected dialect attribute");
+    auto dialectNamePair = attr.first.strref().split('.');
+    return fn.getContext()->getRegisteredDialect(dialectNamePair.first);
+  }
+
   template <typename ErrorContext>
   bool verifyAttribute(Attribute attr, const ErrorContext &ctx) {
     if (!attr.isOrContainsFunction())
@@ -103,7 +113,7 @@ class FuncVerifier {
   bool verifyInstDominance(const Instruction &inst);
 
   explicit FuncVerifier(const Function &fn)
-      : fn(fn), attrNameRegex("^:?[a-zA-Z_][a-zA-Z_0-9\\.\\$]*$") {}
+      : fn(fn), identifierRegex("^[a-zA-Z_][a-zA-Z_0-9\\.\\$]*$") {}
 
 private:
   /// The function being checked.
@@ -113,7 +123,7 @@ class FuncVerifier {
   DominanceInfo *domInfo = nullptr;
 
   /// Regex checker for attribute names.
-  llvm::Regex attrNameRegex;
+  llvm::Regex identifierRegex;
 };
 } // end anonymous namespace
 
@@ -122,29 +132,53 @@ bool FuncVerifier::verify() {
                                    fn.getName().c_str());
 
   // Check that the function name is valid.
-  llvm::Regex funcNameRegex("^[a-zA-Z_][a-zA-Z_0-9\\.\\$]*$");
-  if (!funcNameRegex.match(fn.getName().strref()))
+  if (!identifierRegex.match(fn.getName().strref()))
     return failure("invalid function name '" + fn.getName().strref() + "'", fn);
 
   /// Verify that all of the attributes are okay.
   for (auto attr : fn.getAttrs()) {
-    if (!attrNameRegex.match(attr.first))
+    if (!identifierRegex.match(attr.first))
       return failure("invalid attribute name '" + attr.first.strref() + "'",
                      fn);
     if (verifyAttribute(attr.second, fn))
       return true;
+
+    /// Check that the attribute is a dialect attribute, i.e. contains a '.' for
+    /// the namespace.
+    if (!attr.first.strref().contains('.')) {
+      // TODO: Remove the remaining usages of non dialect attributes on
+      // functions and then enable this check.
+      // return failure("functions may only have dialect attributes", fn);
+      continue;
+    }
+
+    // Verify this attribute with the defining dialect.
+    if (auto *dialect = getDialectForAttribute(attr, fn))
+      if (dialect->verifyFunctionAttribute(&fn, attr.second))
+        return true;
   }
 
   /// Verify that all of the argument attributes are okay.
   for (unsigned i = 0, e = fn.getNumArguments(); i != e; ++i) {
     for (auto attr : fn.getArgAttrs(i)) {
-      if (!attrNameRegex.match(attr.first))
+      if (!identifierRegex.match(attr.first))
         return failure(
             llvm::formatv("invalid attribute name '{0}' on argument {1}",
                           attr.first.strref(), i),
             fn);
       if (verifyAttribute(attr.second, fn))
         return true;
+
+      /// Check that the attribute is a dialect attribute, i.e. contains a '.'
+      /// for the namespace.
+      if (!attr.first.strref().contains('.'))
+        return failure("function arguments may only have dialect attributes",
+                       fn);
+
+      // Verify this attribute with the defining dialect.
+      if (auto *dialect = getDialectForAttribute(attr, fn))
+        if (dialect->verifyFunctionArgAttribute(&fn, i, attr.second))
+          return true;
     }
   }
 
@@ -257,11 +291,18 @@ bool FuncVerifier::verifyOperation(const Instruction &op) {
 
   /// Verify that all of the attributes are okay.
   for (auto attr : op.getAttrs()) {
-    if (!attrNameRegex.match(attr.first))
+    if (!identifierRegex.match(attr.first))
       return failure("invalid attribute name '" + attr.first.strref() + "'",
                      op);
     if (verifyAttribute(attr.second, op))
       return true;
+
+    // Check for any optional dialect specific attributes.
+    if (!attr.first.strref().contains('.'))
+      continue;
+    if (auto *dialect = getDialectForAttribute(attr, op))
+      if (dialect->verifyInstructionAttribute(&op, attr.second))
+        return true;
   }
 
   // If we can get operation info for this, check the custom hook.

mlir/lib/IR/AsmPrinter.cpp

@@ -77,12 +77,6 @@ static llvm::cl::opt<bool>
                        llvm::cl::desc("Print the generic op form"),
                        llvm::cl::init(false), llvm::cl::Hidden);
 
-static llvm::cl::opt<bool> printInternalAttributes(
-    "mlir-print-internal-attributes",
-    llvm::cl::desc(
-        "Print internal function and instruction attributes (':' prefix)."),
-    llvm::cl::init(false));
-
 namespace {
 class ModuleState {
 public:
@@ -1022,21 +1016,13 @@ void ModulePrinter::printOptionalAttrDict(ArrayRef<NamedAttribute> attrs,
   // Filter out any attributes that shouldn't be included.
   SmallVector<NamedAttribute, 8> filteredAttrs;
   for (auto attr : attrs) {
-    auto attrName = attr.first.strref();
-    // By default, never print attributes that start with a colon.  These are
-    // attributes represent location or other internal metadata.
-    if (!printInternalAttributes && attrName.startswith(":"))
-      return;
-
     // If the caller has requested that this attribute be ignored, then drop it.
-    bool ignore = false;
-    for (auto elide : elidedAttrs)
-      ignore |= attrName == elide;
+    if (llvm::any_of(elidedAttrs,
+                     [&](StringRef elided) { return attr.first.is(elided); }))
+      continue;
 
     // Otherwise add it to our filteredAttrs list.
-    if (!ignore) {
-      filteredAttrs.push_back(attr);
-    }
+    filteredAttrs.push_back(attr);
   }
 
   // If there are no attributes left to print after filtering, then we're done.

mlir/lib/Parser/Parser.cpp

@@ -1432,25 +1432,19 @@ ParseResult Parser::parseLocationInstance(llvm::Optional<Location> *loc) {
 ///
 ///   attribute-dict ::= `{` `}`
 ///                    | `{` attribute-entry (`,` attribute-entry)* `}`
-///   attribute-entry ::= `:`? bare-id `:` attribute-value
+///   attribute-entry ::= bare-id `:` attribute-value
 ///
 ParseResult
 Parser::parseAttributeDict(SmallVectorImpl<NamedAttribute> &attributes) {
   if (!consumeIf(Token::l_brace))
     return ParseFailure;
 
   auto parseElt = [&]() -> ParseResult {
-    // Check for an internal attribute.
-    bool isInternalAttr = consumeIf(Token::colon);
-
     // We allow keywords as attribute names.
     if (getToken().isNot(Token::bare_identifier, Token::inttype) &&
         !getToken().isKeyword())
       return emitError("expected attribute name");
-    Identifier nameId =
-        isInternalAttr
-            ? builder.getIdentifier(Twine(":" + getTokenSpelling()).str())
-            : builder.getIdentifier(getTokenSpelling());
+    Identifier nameId = builder.getIdentifier(getTokenSpelling());
     consumeToken();
 
     if (parseToken(Token::colon, "expected ':' in attribute list"))