[mlir][doc] fix typos.

[jcai19]

Summary

This fixes some typos in OpDefinitions.md and DeclarativeRewrites.md,
and wrap function/class names in backticks.

[bondhugula]

Thanks - a couple of comments.

mlir/docs/DeclarativeRewrites.md

545

This sentence is still broken.

onput -> output?

[jcai19]

Fix my typos.

[jcai19]

In D110582#3026567, @bondhugula wrote:

Thanks - a couple of comments.

Thanks for noticing that. I've fix the typos.

[mehdi_amini]

LG, thanks

[jcai19]

In D110582#3040493, @mehdi_amini wrote:

LG, thanks

Thanks!

mlir/docs/DeclarativeRewrites.md

let results = (outs
       AnyType:$op_output
     );
 }
 ```
 
 We can write a C++ helper function:
 
 ```c++
-Attribute createArrayAttr(Builder &builder, Attribute a, Attribute b) {
+ArrayAttr createArrayAttr(Builder &builder, Attribute a, Attribute b) {
   return builder.getArrayAttr({a, b});
 }
 ```
 
 And then write the pattern as:
 
 ```tablegen
 def createArrayAttr : NativeCodeCall<"createArrayAttr($_builder, $0, $1)">;

 
 ```tablegen
 
 def : Pat<(OneAttrOp (NativeCodeCall<"Foo($_self, &$0)"> I32Attr:$val)),
           (TwoAttrOp $val, $val)>;
 ```
 
 In the above, `$_self` is substituted by the defining operation of the first
-operand of OneAttrOp. Note that we don't support binding name to NativeCodeCall
-in the source pattern. To carry some return values from helper function, put the
+operand of OneAttrOp. Note that we don't support binding name to `NativeCodeCall`
+in the source pattern. To carry some return values from a helper function, put the
 names (constraint is optional) in the parameter list and they will be bound to
-the variables with correspoding type. Then these named must be either passed by
-reference or a pointer to variable used as argument so that the matched value
+the variables with correspoding type. Then these names must be either passed by
+reference or pointer to the variable used as argument so that the matched value
 can be returned. In the same example, `$val` will be bound to a variable with
-`Attribute` type(as `I32Attr`) and the type of the second argument in Foo()
+`Attribute` type (as `I32Attr`) and the type of the second argument in `Foo()`
 could be `Attribute&` or `Attribute*`. Names with attribute constraints will be
-captured as Attributes while everything else will be treated as Value.
+captured as `Attribute`s while everything else will be treated as `Value`s.
 
 Positional placeholders will be substituted by the `dag` object parameters at
 the `NativeCodeCall` use site. For example, if we define `SomeCall :
 NativeCodeCall<"someFn($1, $2, $0)">` and use it like `(SomeCall $in0, $in1,
 $in2)`, then this will be translated into C++ call `someFn($in1, $in2, $in0)`.
 
 Positional range placeholders will be substituted by multiple `dag` object
 parameters at the `NativeCodeCall` use site. For example, if we define

 
 def PackAttrs : NativeCodeCall<"packAttrs($0, $1)", 2>;
 def : Pattern<(TwoResultOp $attr1, $attr2),
               [(OneResultOp (PackAttr:$res__0, $attr1, $attr2)),
                (OneResultOp $res__1)]>;
 
 ```
 
-Use `NativeCodeCallVoid` for case has no return value.
+Use `NativeCodeCallVoid` for cases with no return value.
 
 The correct number of returned value specified in NativeCodeCall is important.
-It will be used to verify the consistency of the number of result values.
-Additionally, `mlir-tblgen` will try to capture the return value of
-NativeCodeCall in the generated code so that it will trigger a later compilation
-error if a NativeCodeCall that doesn't return a result isn't labeled with 0
+It will be used to verify the consistency of the number of return values.
+Additionally, `mlir-tblgen` will try to capture the return values of
+`NativeCodeCall` in the generated code so that it will trigger a later compilation
+error if a `NativeCodeCall` that doesn't return any result isn't labeled with 0
 returns.
 
 ##### Customizing entire op building
 
 `NativeCodeCall` is not only limited to transforming arguments for building an
 op; it can be also used to specify how to build an op entirely. An example:
 
 If we have a C++ function for building an op:

 [variadic](#supporting-variadic-ops)). For example, we can bind a symbol to some
 multi-result op and reference a specific result later:
 
 ```tablegen
 def ThreeResultOp : Op<"three_result_op"> {
     let arguments = (ins ...);
 
     let results = (outs
-      AnyTensor:$op_output1,
-      AnyTensor:$op_output2,
-      AnyTensor:$op_output3
+      AnyTensor:$output1,
+      AnyTensor:$output2,
+      AnyTensor:$output3
     );
 }
 
 def : Pattern<(ThreeResultOp:$results ...),
               [(... $results__0), ..., (... $results__2), ...]>;
 ```
 
 In the above pattern we bind `$results` to all the results generated by
-`ThreeResultOp` and references its `$input1` and `$input3` later in the result
+`ThreeResultOp` and references its `$output1` and `$output3` later in the result
 patterns.
 
 We can also bind a symbol and reference one of its specific result at the same
 time, which is typically useful when generating multi-result ops:
 
 ```tablegen
 // TwoResultOp has similar definition as ThreeResultOp, but only has two
 // results.

 
 In the above pattern, the generated `LocDst2Op` will use the matched location of
 `LocSrc2Op` while the root `LocDst1Op` node will used the named location
 `outer`.
 
 ### `replaceWithValue`
 
 The `replaceWithValue` directive is used to eliminate a matched op by replacing
-all of it uses with a captured value. It is of the following syntax:
+all of its uses with a captured value. It is of the following syntax:
 
 ```tablegen
 (replaceWithValue $symbol)
 ```
 
 where `$symbol` should be a symbol bound previously in the pattern.
 
 For example,

mlir/docs/OpDefinitions.md

 `$_builder`, `$_op`, and `$_self`:
 
 *   `$_builder` will be replaced by a `mlir::Builder` instance so that you can
     access common build methods.
 *   `$_op` will be replaced by the current operation so that you can access
     information of the current operation.
 *   `$_self` will be replaced with the entity this predicate is attached to.
     E.g., `BoolAttr` is an attribute constraint that wraps a
-    `CPred<"$_self.isa<BoolAttr>()">`. Then for `F32Attr:$attr`,`$_self` will be
+    `CPred<"$_self.isa<BoolAttr>()">`. Then for `BoolAttr:$attr`,`$_self` will be
     replaced by `$attr`. For type constraints, it's a little bit special since
     we want the constraints on each type definition reads naturally and we want
     to attach type constraints directly to an operand/result, `$_self` will be
     replaced by the operand/result's type. E.g., for `F32` in `F32:$operand`,
     its `$_self` will be expanded as `operand(...).getType()`.
 
 TODO: Reconsider the leading symbol for special placeholders. Eventually we want
 to allow referencing operand/result `$-name`s; such `$-name`s can start with