Update syntax for tensor and memref types to match parser.

[richard-uhler]

Summary

Based on the comments in lib/Parser/TypeParser.cpp on the
parseMemRefType and parseTensorType functions.

[mehdi_amini]

mlir/docs/LangRef.md

940

The strided layout is a valid part of the syntax. It is the code in TypeParser.cpp that isn't up to date I believe.

[richard-uhler]

Include strided-layout in the syntax for memref.

[mehdi_amini]

mlir/lib/Parser/TypeParser.cpp

192

I think this should be a semi-affine-map-composition

[richard-uhler]

Use semi-affine-map-composition instead of semi-affine-map.

[richard-uhler]

Include definition of semi-affine-map-composition syntax.

[richard-uhler]

Can you submit this for me?

mlir/docs/LangRef.md

 
 #### Memref Type
 
 Syntax:
 
 ```
 memref-type ::= ranked-memref-type | unranked-memref-type
 
-ranked-memref-type ::= `memref` `<` dimension-list-ranked tensor-memref-element-type
+ranked-memref-type ::= `memref` `<` dimension-list-ranked type
                       (`,` layout-specification)? (`,` memory-space)? `>`
 
-unranked-memref-type ::= `memref` `<*x` tensor-memref-element-type
-                         (`,` memory-space)? `>`
+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
+semi-affine-map-composition ::= (semi-affine-map `,` )* semi-affine-map
+layout-specification ::= semi-affine-map-composition | strided-layout
 memory-space ::= integer-literal /* | TODO: address-space-id */
 ```
 
 A `memref` type is a reference to a region of memory (similar to a buffer
 pointer, but more powerful). The buffer pointed to by a memref can be allocated,
 aliased and deallocated. A memref can be used to read and write data from/to the
 memory region which it references. Memref types use the same shape specifier as
 tensor types. Note that `memref<f32>`, `memref<0 x f32>`, `memref<1 x 0 x f32>`,

 The `none` type is a unit type, i.e. a type with exactly one possible value,
 where its value does not have a defined dynamic representation.
 
 #### Tensor Type
 
 Syntax:
 
 ```
-tensor-type ::= `tensor` `<` dimension-list tensor-memref-element-type `>`
-tensor-memref-element-type ::= vector-element-type | vector-type | complex-type
+tensor-type ::= `tensor` `<` dimension-list type `>`
 
-// memref requires a known rank, but tensor does not.
 dimension-list ::= dimension-list-ranked | (`*` `x`)
 dimension-list-ranked ::= (dimension `x`)*
 dimension ::= `?` | decimal-literal
 ```
 
 Values with tensor type represents aggregate N-dimensional data values, and
 have a known element type. It may have an unknown rank (indicated by `*`) or may
 have a fixed rank with a list of dimensions. Each dimension may be a static

mlir/lib/Parser/TypeParser.cpp

ParseResult Parser::parseStridedLayout(int64_t &offset,
   return success();
 }
 
 /// Parse a memref type.
 ///
 ///   memref-type ::= ranked-memref-type | unranked-memref-type
 ///
 ///   ranked-memref-type ::= `memref` `<` dimension-list-ranked type
-///                          (`,` semi-affine-map-composition)? (`,`
-///                          memory-space)? `>`
+///                          (`,` layout-specification)? (`,` memory-space)? `>`
 ///
 ///   unranked-memref-type ::= `memref` `<*x` type (`,` memory-space)? `>`
 ///
+///   stride-list ::= `[` (dimension (`,` dimension)*)? `]`
+///   strided-layout ::= `offset:` dimension `,` `strides: ` stride-list
 ///   semi-affine-map-composition ::= (semi-affine-map `,` )* semi-affine-map
+///   layout-specification ::= semi-affine-map-composition | strided-layout
 ///   memory-space ::= integer-literal /* | TODO: address-space-id */
 ///
 Type Parser::parseMemRefType() {
   consumeToken(Token::kw_memref);
 
   if (parseToken(Token::less, "expected '<' in memref type"))
     return nullptr;
 
   bool isUnranked;