issue#62488: Correct some syntax errors. Leave location and custom-operation-format unchanged, because I'm not sure.

[Stevengre]

Documentation flaws in Affine Dialect of MLIR #62490

mlir/docs/Dialects/Affine.md

 $(i, j)$.
 
 ### Affine Maps
 
 Syntax:
 
 ```
 affine-map-inline
-   ::= dim-and-symbol-id-lists `->` multi-dim-affine-expr
+   ::= dim-and-symbol-value-lists `->` multi-dim-affine-expr
 ```
 
 The identifiers in the dimensions and symbols lists must be unique. These are
 the only identifiers that may appear in 'multi-dim-affine-expr'. Affine maps
 with one or more symbols in its specification are known as "symbolic affine
 maps", and those with no symbols as "non-symbolic affine maps".
 
 **Context:** Affine maps are mathematical functions that transform a list of

 
 The precedence and associativity of operations in the syntax above is the same
 as that for [affine expressions](#affine-expressions).
 
 Syntax of semi-affine maps:
 
 ```
 semi-affine-map-inline
-   ::= dim-and-symbol-id-lists `->` multi-dim-semi-affine-expr
+   ::= dim-and-symbol-value-lists `->` multi-dim-semi-affine-expr
 ```
 
 Semi-affine maps may be defined inline at the point of use, or may be hoisted to
 the top of the file and given a name with a semi-affine map definition, and used
 by name.
 
 ```
 semi-affine-map-id ::= `#` suffix-id

 Integer sets may be defined inline at the point of use, or may be hoisted to the
 top of the file and given a name with an integer set definition, and used by
 name.
 
 ```
 integer-set-id ::= `#` suffix-id
 
 integer-set-inline
-   ::= dim-and-symbol-id-lists `:` '(' affine-constraint-conjunction? ')'
+   ::= dim-and-symbol-value-lists `:` '(' affine-constraint-conjunction? ')'
 
 // Declarations of integer sets are at the top of the file.
 integer-set-decl ::= integer-set-id `=` integer-set-inline
 
 // Uses of integer sets may use the inline form or the named form.
 integer-set ::= integer-set-id | integer-set-inline
 ```
 

mlir/docs/LangRef.md

 value-id ::= `%` suffix-id
 alias-name :: = bare-id
 suffix-id ::= (digit+ | ((letter|id-punct) (letter|id-punct|digit)*))
 
 symbol-ref-id ::= `@` (suffix-id | string-literal) (`::` symbol-ref-id)?
 value-id-list ::= value-id (`,` value-id)*
 
 // Uses of value, e.g. in an operand list to an operation.
-value-use ::= value-id
+value-use ::= value-id (`#` decimal-literal)?
 value-use-list ::= value-use (`,` value-use)*
 ```
 
 Identifiers name entities such as values, types and functions, and are chosen by
 the writer of MLIR code. Identifiers may be descriptive (e.g. `%batch_size`,
 `@matmul`), or may be non-descriptive when they are auto-generated (e.g. `%23`,
 `@func42`). Identifier names for values may be used in an MLIR text file but are
 not persisted as part of the IR - the printer will give them anonymous names

 ```
 operation             ::= op-result-list? (generic-operation | custom-operation)
                           trailing-location?
 generic-operation     ::= string-literal `(` value-use-list? `)`  successor-list?
                           dictionary-properties? 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)
+op-result             ::= value-id (`:` integer-literal)?
 successor-list        ::= `[` successor (`,` successor)* `]`
 successor             ::= caret-id (`:` block-arg-list)?
 dictionary-properties ::= `<` dictionary-attribute `>`
 region-list           ::= `(` region (`,` region)* `)`
 dictionary-attribute  ::= `{` (attribute-entry (`,` attribute-entry)*)? `}`
-trailing-location     ::= (`loc` `(` location `)`)?
+trailing-location     ::= `loc` `(` location `)`
 ```
 
 MLIR introduces a uniform concept called *operations* to enable describing many
 different levels of abstractions and computations. Operations in MLIR are fully
 extensible (there is no fixed list of operations) and have application-specific
 semantics. For example, MLIR supports
 [target-independent operations](Dialects/MemRef.md),
 [affine operations](Dialects/Affine.md), and