[mlir] Small touchups to LangRef attribute section

[silvas]

Summary

• attribute-dict production is redundant with dictionary-attribute
• definitions of attribute aliases were part of the same production as uses of attribute aliases
• std.dim now accepts the dimension number as an operand, so the example is out of date. Use the predicate of std.cmpi as a better example.

mlir/docs/LangRef.md

 ## Operations
 
 Syntax:
 
 ```
 operation         ::= op-result-list? (generic-operation | custom-operation)
                       trailing-location?
 generic-operation ::= string-literal `(` value-use-list? `)`  successor-list?
-                      (`(` region-list `)`)? attribute-dict? `:` function-type
+                      (`(` region-list `)`)? dictionary-attribute? `:` function-type
 custom-operation  ::= bare-id custom-operation-format
 op-result-list    ::= op-result (`,` op-result)* `=`
 op-result         ::= value-id (`:` integer-literal)
 successor-list    ::= successor (`,` successor)*
 successor         ::= caret-id (`:` bb-arg-list)?
 region-list       ::= region (`,` region)*
 trailing-location ::= (`loc` `(` location `)`)?
 ```

 // Branch to ^bb1 or ^bb2 depending on the condition %cond.
 // Pass value %v to ^bb2, but not to ^bb1.
 "cond_br"(%cond)[^bb1, ^bb2(%v : index)] : (i1) -> ()
 ```
 
 ### Module
 
 ```
-module ::= `module` symbol-ref-id? (`attributes` attribute-dict)? region
+module ::= `module` symbol-ref-id? (`attributes` dictionary-attribute)? region
 ```
 
 An MLIR Module represents a top-level container operation. It contains a single
 [SSACFG region](#control-flow-and-ssacfg-regions) containing a single block
 which can contain any operations. Operations within this region cannot
 implicitly capture values defined outside the module, i.e. Modules are
 [IsolatedFromAbove](Traits.md#isolatedfromabove). Modules have an optional
 [symbol name](SymbolsAndSymbolTables.md) which can be used to refer to them in

 
 ```
 function ::= `func` function-signature function-attributes? function-body?
 
 function-signature ::= symbol-ref-id `(` argument-list `)`
                        (`->` function-result-list)?
 
 argument-list ::= (named-argument (`,` named-argument)*) | /*empty*/
-argument-list ::= (type attribute-dict? (`,` type attribute-dict?)*) | /*empty*/
-named-argument ::= value-id `:` type attribute-dict?
+argument-list ::= (type dictionary-attribute? (`,` type dictionary-attribute?)*)
+                | /*empty*/
+named-argument ::= value-id `:` type dictionary-attribute?
 
 function-result-list ::= function-result-list-parens
                        | non-function-type
 function-result-list-parens ::= `(` `)`
                               | `(` function-result-list-no-parens `)`
 function-result-list-no-parens ::= function-result (`,` function-result)*
-function-result ::= type attribute-dict?
+function-result ::= type dictionary-attribute?
 
-function-attributes ::= `attributes` attribute-dict
+function-attributes ::= `attributes` dictionary-attribute
 function-body ::= region
 ```
 
 An external function declaration (used when referring to a function declared
 in some other module) has no body. While the MLIR textual form provides a nice
 inline syntax for function arguments, they are internally represented as
 "block arguments" to the first block in the region.
 

 `vector<0x42xi32>` is invalid because it is interpreted as a 2D vector with
 shape `(0, 42)` and zero shapes are not allowed.
 
 ## Attributes
 
 Syntax:
 
 ```
-attribute-dict ::= `{` `}`
-                 | `{` attribute-entry (`,` attribute-entry)* `}`
 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|[_$])*)
                            | string-literal
 ```
 
 Attributes are the mechanism for specifying constant data on operations in
-places where a variable is never allowed - e.g. the index of a
-[`dim` operation](Dialects/Standard.md#stddim-dimop), or the stride of a
+places where a variable is never allowed - e.g. the comparison predicate of a
+[`cmpi` operation](Dialects/Standard.md#stdcmpi-cmpiop), or the stride of a
 convolution. They consist of a name and a concrete attribute value. The set of
 expected attributes, their structure, and their interpretation are all
 contextually dependent on what they are attached to.
 
 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.
 
 Attribute values are represented by the following forms:
 
 ```
 attribute-value ::= attribute-alias | dialect-attribute | builtin-attribute
 ```
 
 ### Attribute Value Aliases
 
 ```
-attribute-alias ::= '#' alias-name '=' attribute-value
+attribute-alias-def ::= '#' alias-name '=' attribute-value
 attribute-alias ::= '#' alias-name
 ```
 
 MLIR supports defining named aliases for attribute values. An attribute alias is
 an identifier that can be used in the place of the attribute that it defines.
 These aliases *must* be defined before their uses. Alias names may not contain a
 '.', since those names are reserved for
 [dialect attributes](#dialect-attribute-values).