[flang] Fixed a number of typos

[GabrielRavier]

Summary

I went over the output of the following mess of a command:

(ulimit -m 2000000; ulimit -v 2000000; git ls-files -z | parallel --xargs -0 cat | aspell list --mode=none --ignore-case | grep -E '^[A-Za-z][a-z]*$' | sort | uniq -c | sort -n | grep -vE '.{25}' | aspell pipe -W3 | grep : | cut -d' ' -f2 | less)

and proceeded to spend a few days looking at it to find probable typos
and fixed a few hundred of them in all of the llvm project (note, the
ones I found are not anywhere near all of them, but it seems like a
good start).

[clementval]

LGTM

[awarzynski]

LGTM, thanks for doing this!

[clementval]

Do you need help to land this?

[GabrielRavier]

In D130844#3748265, @clementval wrote:

Do you need help to land this?

I don't have commit access so yes (btw, since I recall this being needed, my Author field is Gabriel Ravier <[e-mail]>)

[clementval]

In D130844#3748374, @GabrielRavier wrote:

In D130844#3748265, @clementval wrote:

Do you need help to land this?

I don't have commit access so yes (btw, since I recall this being needed, my Author field is Gabriel Ravier <[e-mail]>)

I just pushed it. You should ask for access if you plan to contribute more.

flang/docs/Extensions.md

 * $ and \ edit descriptors are supported in FORMAT to suppress newline
   output on user prompts.
 * Tabs in format strings (not `FORMAT` statements) are allowed on output.
 * REAL and DOUBLE PRECISION variable and bounds in DO loops
 * Integer literals without explicit kind specifiers that are out of range
   for the default kind of INTEGER are assumed to have the least larger kind
   that can hold them, if one exists.
 * BOZ literals can be used as INTEGER values in contexts where the type is
-  unambiguous: the right hand sides of assigments and initializations
+  unambiguous: the right hand sides of assignments and initializations
   of INTEGER entities, as actual arguments to a few intrinsic functions
   (ACHAR, BTEST, CHAR), and as actual arguments of references to
   procedures with explicit interfaces whose corresponding dummy
   argument has a numeric type to which the BOZ literal may be
   converted.  BOZ literals are interpreted as default INTEGER only
   when they appear as the first items of array constructors with no
   explicit type.  Otherwise, they generally cannot be used if the type would
   not be known (e.g., `IAND(X'1',X'2')`).

 * ALLOCATE(TYPE(derived)::...) as variant of correct ALLOCATE(derived::...) (PGI only)
 * Defining an explicit interface for a subprogram within itself (PGI only)
 * USE association of a procedure interface within that same procedure's definition
 * NULL() as a structure constructor expression for an ALLOCATABLE component (PGI).
 * Conversion of LOGICAL to INTEGER in expressions.
 * Use of INTEGER data with the intrinsic logical operators `.NOT.`, `.AND.`, `.OR.`,
   and `.XOR.`.
 * IF (integer expression) THEN ... END IF  (PGI/Intel)
-* Comparsion of LOGICAL with ==/.EQ. rather than .EQV. (also .NEQV.) (PGI/Intel)
+* Comparison of LOGICAL with ==/.EQ. rather than .EQV. (also .NEQV.) (PGI/Intel)
 * Procedure pointers in COMMON blocks (PGI/Intel)
 * Underindexing multi-dimensional arrays (e.g., A(1) rather than A(1,1)) (PGI only)
 * Legacy PGI `NCHARACTER` type and `NC` Kanji character literals
 * Using non-integer expressions for array bounds (e.g., REAL A(3.14159)) (PGI/Intel)
 * Mixing INTEGER types as operands to bit intrinsics (e.g., IAND); only two
   compilers support it, and they disagree on sign extension.
 * Module & program names that conflict with an object inside the unit (PGI only).
 * When the same name is brought into scope via USE association from

flang/docs/FIRArrayOperations.md

 ```
 
 This operation merges the original loaded array value, `%v`, with the
 chained updates, `%r`, and stores the result to the array at address, `%a`.
 
 This operation taken with `array_load`'s captures Fortran's
 copy-in/copy-out semantics. The first operands of `array_merge_store` is the
 result of the initial `array_load` operation. While this value could be
-retrieved by reference chasiing through the different array operations it is
+retrieved by reference chasing through the different array operations it is
 useful to have it on hand directly for analysis passes since this directly
 defines the "bounds" of the Fortran statement represented by these operations.
 The intention is to allow copy-in/copy-out regions to be easily delineated,
 analyzed, and optimized.
 
 ## array_fetch
 
 The `array_fetch` operation fetches the value of an element in an array value.

flang/examples/FlangOmpReport/yaml_summarizer.py

 
 Pseudo-examples:
 
     Summary:
 
     $ python3 yaml_summarizer.py file_1.yaml file_2.yaml
     <Unique OMP constructs with there grouped clauses from file_1.yaml and file_2.yaml>
 
-    Construcsts are in the form:
+    Constructs are in the form:
     - construct: someOMPconstruct
     count: 8
     clauses:
     - clause: clauseOne
         count: 4
     - clause: ClauseTwo
         count: 2
 

flang/lib/Optimizer/CodeGen/TargetRewrite.cpp

public:
   /// As the type signature is being changed, this must also update the
   /// function itself to use any new arguments, etc.
   mlir::LogicalResult convertTypes(mlir::ModuleOp mod) {
     for (auto fn : mod.getOps<mlir::func::FuncOp>())
       convertSignature(fn);
     return mlir::success();
   }
 
-  /// If the signature does not need any special target-specific converions,
+  /// If the signature does not need any special target-specific conversions,
   /// then it is considered portable for any target, and this function will
   /// return `true`. Otherwise, the signature is not portable and `false` is
   /// returned.
   bool hasPortableSignature(mlir::Type signature) {
     assert(signature.isa<mlir::FunctionType>());
     auto func = signature.dyn_cast<mlir::FunctionType>();
     for (auto ty : func.getResults())
       if ((ty.isa<fir::BoxCharType>() && !noCharacterConversion) ||

flang/lib/Semantics/check-nullify.cpp

common::visit(
             },
         },
         pointerObject.u);
   }
   // From 9.7.3.1(1)
   //   A pointer-object shall not depend on the value,
   //   bounds, or association status of another pointer-
   //   object in the same NULLIFY statement.
-  // This restriction is the programmer's responsibilty.
+  // This restriction is the programmer's responsibility.
   // Some dependencies can be found compile time or at
   // runtime, but for now we choose to skip such checks.
 }
 } // namespace Fortran::semantics

flang/test/Driver/default-backend-pipelines.f90

-! Verify that`-O{n}` is indeed taken into account when definining the LLVM backend pass pipeline.
+! Verify that`-O{n}` is indeed taken into account when defining the LLVM backend pass pipeline.
 
 ! REQUIRES: aarch64-registered-target
 
 ! RUN: %flang_fc1 -S -O2 %s -triple aarch64-unknown-linux-gnu -mllvm -debug-pass=Structure -o /dev/null 2>&1 | FileCheck %s --check-prefix=CHECK-O2
 ! RUN: %flang_fc1 -S -O3 %s -triple aarch64-unknown-linux-gnu -mllvm -debug-pass=Structure -o /dev/null 2>&1 | FileCheck %s --check-prefix=CHECK-O3
 
 ! CHECK-O2-NOT: SVE intrinsics optimizations
 
 ! CHECK-O3: SVE intrinsics optimizations
 
 subroutine simple_loop
   integer :: i
   do i=1,5
   end do
 end subroutine

flang/test/Semantics/altreturn06.f90

 ! RUN: %python %S/test_errors.py %s %flang_fc1
-! Test alternat return argument passing for internal and external subprograms
+! Test alternate return argument passing for internal and external subprograms
 ! Both of the following are OK
   call extSubprogram (*100)
   call intSubprogram (*100)
   call extSubprogram (*101)
   call intSubprogram (*101)
 100 PRINT *,'First alternate return'
 !ERROR: Label '101' is not a branch target
 !ERROR: Label '101' is not a branch target
 101 FORMAT("abc")
 contains
   subroutine intSubprogram(*)
     return(1)
   end subroutine
 end

flang/test/Semantics/call27.f90

 ! RUN: %python %S/test_errors.py %s %flang_fc1
-! Catch NULL() actual argement association with allocatable dummy argument
+! Catch NULL() actual argument association with allocatable dummy argument
 program test
   !ERROR: Null actual argument 'NULL()' may not be associated with allocatable dummy argument 'a='
   call foo1(null())
   !ERROR: Null actual argument 'NULL()' may not be associated with allocatable dummy argument 'a='
   call foo2(null()) ! perhaps permissible later on user request
   call foo3(null()) ! ok
  contains
   subroutine foo1(a)