Fix typos

compiler/AST/baseAST.cpp

@@ -552,7 +552,7 @@ static Symbol* lookupTransitively(SymbolMap* map, Symbol* sym) {
   Symbol* x = map->get(sym);
   if (!x) return x;
 
-  // If the symbol is re-maped again (e.g., x was y and y was z),
+  // If the symbol is re-mapped again (e.g., x was y and y was z),
   // we need to keep looking until we find the final symbol.
   while (Symbol* y = map->get(x)) {
     // Detect naive cycles. Note that this will not find multi-step cycles,

compiler/codegen/cg-stmt.cpp

@@ -188,7 +188,7 @@ GenRet BlockStmt::codegen() {
 ********************************* | ********************************/
 
 // If this is 'if gCpuVsGpuToken then ... else ...'
-// then return the approrpiate branch, else nil.
+// then return the appropriate branch, else nil.
 static BlockStmt* chooseCpuVsGpuBranch(CondStmt* cond) {
   if (SymExpr* se = toSymExpr(cond->condExpr))
     if (se->symbol() == gCpuVsGpuToken)

compiler/optimizations/gpuTransforms.cpp

@@ -1218,7 +1218,7 @@ void KernelArg::findReduceKind() {
   // do some pattern matching in the AST to find the reduce kind
   // This should be OK except that `accumulate` in SumReduceScanOp is the only
   // accumulate proc that's inlined. So, we'll have to do some matching on the
-  // inlined function, which is never great. Morever, if we inline another
+  // inlined function, which is never great. Moreover, if we inline another
   // accumulate function in one of the other reduction types, it'll probably be
   // an unsupported reduction.
   //
@@ -1520,7 +1520,7 @@ Symbol* GpuKernel::addKernelArgument(Symbol* symInLoop, bool isCompilerGenerated
       this->incReductionBufs();
     }
 
-    // if reduction variable, add the function definiton for the final reduction
+    // if reduction variable, add the function definition for the final reduction
     // wrapper
     if (FnSymbol* reduceWrapper = arg.reduceWrapper()) {
       fn_->defPoint->insertBefore(new DefExpr(reduceWrapper));
@@ -1752,7 +1752,7 @@ void GpuKernel::generatePostBody() {
   fn_->insertAtTail(this->postBody_);
 }
 
-// Returns the GPU primives block within 'body', or null if none.
+// Returns the GPU primitives block within 'body', or null if none.
 // Note: this searches inside nested loops - needed for multi-dim arrays, ex:
 //   var A: [1..n,1..n] int;
 //   @gpu.blockSize foreach A {}
@@ -2452,7 +2452,7 @@ static void cleanupPrimitives() {
       //     var taskIndX = PRIM_TASK_IND_CAPTURE_OF(copy-of(x));
       //
       // For gpuized loops GPU lowering rewrites this as needed to ensure each thread
-      // has an indpendent copy-of x, loops that are not gpuized will have remaining
+      // has an independent copy-of x, loops that are not gpuized will have remaining
       // uses of the primitive, which we process by removing the primitive but keeping
       // the copy.
       callExpr->replace(callExpr->get(1)->remove());

compiler/passes/convert-typed-uast.cpp

@@ -551,7 +551,7 @@ ModuleSymbol* TConverter::convertModule(const Module* mod) {
   submodulesEncountered.clear();
   convertModuleInit(mod, modSym);
 
-  // Additionally, convert any submodules encontered.
+  // Additionally, convert any submodules encountered.
   // This is handled as a follow-on step in order to avoid storing
   // various pieces of TConverter state in a stack.
   for (const uast::Module* submod : submodulesEncountered) {
@@ -1544,7 +1544,7 @@ Type* TConverter::helpConvertClassType(const types::ClassType* t) {
 
   const types::RecordType* manager = t->managerRecordType(context);
   if (manager == nullptr) {
-    ret = at; // unamanged / borrowed is just the class type at this point
+    ret = at; // unmanaged / borrowed is just the class type at this point
   } else {
     // owned/shared should have had a substitution for chpl_t
     CHPL_ASSERT(!manager->substitutions().empty());

compiler/passes/convert-uast.cpp

@@ -3674,7 +3674,7 @@ struct Converter final : UastConverter {
       auto* ident =
         uast::Class::getUnwrappedInheritExpr(inheritExpr, thisInheritMarkedGeneric);
 
-      // Always convert the taraget expression so that we note used modules
+      // Always convert the target expression so that we note used modules
       // as needed. We won't necessarily use the resulting expression;
       // see the comment below.
       auto converted = convertExprOrNull(ident);

compiler/passes/normalize.cpp

@@ -404,7 +404,7 @@ static void preNormalizeHandleStaticVars() {
       // Don't put the reset call into the function body right away because
       // at this time, myStaticVar is a non-global variable, so the function
       // is capturing it. We use the function as an FCF argument to
-      // 'executeStaticWraperCleanup', and capturing FCFs do not work. The
+      // 'executeStaticWrapperCleanup', and capturing FCFs do not work. The
       // relocation of the reset call will happen after the static variable has
       // been hoisted to the module level.
       //
@@ -1776,7 +1776,7 @@ Expr* partOfNonNormalizableExpr(Expr* expr) {
       Expr* root = nullptr;
       if (call->isPrimitive(PRIM_RESOLVES) ||
 
-          // Static resolution calls are not normalizeable so that they
+          // Static resolution calls are not normalizable so that they
           // don't "spill" their call temps outside of the primitive call.
           // If they are "spilled", replacing the primitive with its result
           // will still leave behind the temps; normally these would be

compiler/resolution/functionResolution.cpp

@@ -960,7 +960,7 @@ bool canInstantiate(Type* actualType, Type* formalType) {
         // We may have a 'DecoratedClassType' as one of the arguments
         // (e.g. anymanaged x1) and a regular class (e.g. shared(x2)) as another.
         // This would've failed the check above, since anymanaged x1 is not
-        // an aggregate typem and x1 is not an instantiation of shared(x2), either.
+        // an aggregate type and x1 is not an instantiation of shared(x2), either.
         //
         // By the above condition, x1 != x2, but instantiation is still possible
         // if one of the xs instantiates another. Strip the 'owned' etc.

doc/rst/language/spec/domain-maps.rst

@@ -251,7 +251,7 @@ determined by its type and so does not change upon a domain assignment.
 
    .. code-block:: chapel
 
-      use BlockDist:
+      use BlockDist;
       var Dom1 = blockDist.createDomain({1..5,1..6});
       var Dom2: domain(2) = Dom1;
 

doc/rst/technotes/gpu.rst

@@ -29,7 +29,7 @@ Overview
 The Chapel compiler will generate GPU kernels for certain parallel operations
 such as ``forall``/``foreach`` loops, ``reduce`` expressions and promoted
 expressions. These will be launched onto a GPU when the current locale (e.g.
-``here``) is the sublocale representing that particluar GPU. To deploy code to a
+``here``) is the sublocale representing that particular GPU. To deploy code to a
 GPU, put the relevant code in an ``on`` statement targeting a GPU sublocale
 (i.e. ``here.gpus[0]``).
 

doc/rst/technotes/remote.rst

@@ -8,7 +8,7 @@ Remote Variable Declarations
 .. warning::
 
   This work is under active development. As such, the interface and behavior
-  of tremote variables is unstable and expected to change.
+  of remote variables is unstable and expected to change.
 
 .. contents::
 

doc/rst/technotes/static.rst

@@ -196,7 +196,7 @@ initial value. Subsequent changes to the static variable are only visible to
 the locale. The purpose for this approach is to support the pre-computation of
 values "near" where the computation takes place. This way, each locale can
 reference its own copy of the pre-computed data, without the need for
-any communication. By changing the sharing kind to ``comutePerLocale``:
+any communication. By changing the sharing kind to ``computePerLocale``:
 
 .. code-block:: chapel
 

doc/rst/usingchapel/chplenv.rst

@@ -874,7 +874,7 @@ CHPL_LLVM_GCC_INSTALL_DIR
    Sometimes it's necessary to request that ``clang`` work with a
    particular version of GCC. If many versions are installed at the same
    prefix (e.g. ``/usr``) then ``CHPL_LLVM_GCC_PREFIX`` won't be able to
-   differentate between them. That is where ``CHPL_LLVM_GCC_INSTALL_DIR``
+   differentiate between them. That is where ``CHPL_LLVM_GCC_INSTALL_DIR``
    comes in!
 
    To understand what to set ``CHPL_LLVM_GCC_INSTALL_DIR`` to in such

frontend/include/chpl/framework/Context-detail.h

@@ -260,7 +260,7 @@ class QueryMapResultBase {
   // lastChanged indicates the last revision in which the query result
   // has changed
   mutable RevisionNumber lastChanged = -1;
-  // This field exists to support isQueryRunning. When traversingg the dependencies
+  // This field exists to support isQueryRunning. When traversing the dependencies
   // of a query, we may re-run dependency queries to see if their results change.
   // Sometimes, these queries will check isQueryRunning. At this time, the
   // actual query (this) is not running, but we want to return 'true' to hide

frontend/include/chpl/resolution/ResolutionContext.h

@@ -61,7 +61,7 @@ class MatchingIdsWithName;
   At any point in time, a 'ResolutionContext*' is either stable or unstable.
   It is unstable if it has one or more unstable frames.
 
-  When the 'ResolutionContext*' is unstable, any 'CHPL_RESOUTION_QUERY...'
+  When the 'ResolutionContext*' is unstable, any 'CHPL_RESOLUTION_QUERY...'
   will consult the passed in query arguments in order to determine if the
   'Context*' query cache can be used. If the arguments may refer to a
   nested function, then the computed result is not cached in the global

frontend/include/chpl/resolution/resolution-types.h

@@ -2019,7 +2019,7 @@ class CallResolutionResult {
    the iteration (e.g., lack of a follower iterator)
 
    In the case of failure due to zippering (e.g., we're iterating over a
-   loop expression, but the Nth zippred iterand doesn't have the appropriate
+   loop expression, but the Nth zippered iterand doesn't have the appropriate
    iterator), this type contains a 'zipperedFailure_' field, which contains
    the result of trying to iterate the Nth iterand, and a 'zipperedFailureIndex_'
    which is the index of the failed iterand.

frontend/include/chpl/resolution/scope-queries.h

@@ -215,7 +215,7 @@ namespace resolution {
 
   /**
     Given a Scope* for a Module, return a DeclMap containing all symbols
-    publically available from that module, including those brought in
+    publicly available from that module, including those brought in
     transitively by use/import. */
   const ModulePublicSymbols* publicSymbolsForModule(Context* context, const Scope* modScope);
 

frontend/include/chpl/resolution/scope-types.h

@@ -1373,7 +1373,7 @@ class MethodLookupHelper {
 /** This type helps lookupNameInScope and related functions.
     When performing name lookup within a method, the name
     might refer to a field or tertiary method. Such matches
-    are checked for by searching the method reciver scopes
+    are checked for by searching the method receiver scopes
     at the time that the method signature is encountered in the
     process of searching parent scopes. This type includes
     a method that can return an appropriate MethodLookupHelper

frontend/include/chpl/uast/Builder.h

@@ -160,7 +160,7 @@ class Builder final {
   #include "all-location-maps.h"
   #undef LOCATION_MAP
 
-  /** Delete all the locations storedfor the current AST. This is useful if the
+  /** Delete all the locations stored for the current AST. This is useful if the
       AST is being deallocated, which means future uses of this pointer
       (the memory could be re-used) must not have locations out of the box.
     */

frontend/lib/resolution/InitResolver.cpp

@@ -343,9 +343,9 @@ static const Type* ctFromSubs(Context* context,
   const Type* ret = nullptr;
 
   if (auto rec = receiverType->toRecordType()) {
-    auto instantatiatedFrom = subs.empty() ? nullptr : root->toRecordType();
+    auto instantiatedFrom = subs.empty() ? nullptr : root->toRecordType();
     ret = RecordType::get(context, rec->id(), rec->name(),
-                          instantatiatedFrom,
+                          instantiatedFrom,
                           subs);
   } else if (auto cls = receiverType->toClassType()) {
     auto oldBasic = cls->basicClassType();

frontend/lib/resolution/Resolver.cpp

@@ -3059,7 +3059,7 @@ MatchingIdsWithName Resolver::lookupIdentifier(
     // procs can be ruled out if their 'where' clauses are false. If even
     // one identifier is not a parenless proc, there's an ambiguity.
     //
-    // outParenlessOverloadInfo will be falsey if we found non-parenless-proc
+    // outParenlessOverloadInfo will be false if we found non-parenless-proc
     // IDs. In that case we may emit an ambiguity error later, after filtering
     // out incorrect receivers.
     outParenlessOverloadInfo =
@@ -4982,7 +4982,7 @@ static IterDetails resolveIterDetails(Resolver& rv,
 
   // Only issue a "not iterable" error if the iterand has a type. If it was
   // not typed then earlier resolution of the iterand will have spit out an
-  // approriate error for us already.
+  // appropriate error for us already.
   if (ret.succeededAt == IterDetails::NONE && !iterandRe.type().isUnknownOrErroneous()) {
     auto& iterandRE = rv.byPostorder.byAst(iterand);
     if (!iterandRE.type().isUnknownOrErroneous()) {
@@ -5022,7 +5022,7 @@ static bool isExplicitlyTaggedIteratorCall(Context* context,
 
   // We could've ended up resolving a leader automatically from a serial
   // call (if the serial overload doesn't exist). To check that this was
-  // an explicit tag, we need to not have any ITERATE associted actions.
+  // an explicit tag, we need to not have any ITERATE associated actions.
   auto count = std::count_if(re.associatedActions().begin(),
                              re.associatedActions().end(),
                              [](const AssociatedAction& aa) {
@@ -5363,7 +5363,7 @@ static bool handleArrayTypeExpr(Resolver& rv,
     bodyType = QualifiedType(QualifiedType::TYPE, AnyType::get(rv.context));
   }
 
-  // The body wasn't a type, so this isn't an array type epxression
+  // The body wasn't a type, so this isn't an array type expression
   // Make an exception for unknown or erroneous bodies, since the user may
   // have been trying to define a type but made a mistake (or we may be
   // in a partially-instantiated situation and the type is not yet known).

frontend/lib/resolution/default-functions.cpp

@@ -1215,7 +1215,7 @@ generateCastToEnum(Context* context,
 const TypedFnSignature*
 getCompilerGeneratedMethod(Context* context, const QualifiedType receiverType,
                            UniqueString name, bool parenless) {
-  // Normalize recieverType to allow TYPE methods on c_ptr and _ddata, and to
+  // Normalize receiverType to allow TYPE methods on c_ptr and _ddata, and to
   // otherwise use the VAR Kind. The Param* value is also stripped away to
   // reduce queries.
   auto qt = receiverType;

frontend/lib/resolution/resolution-queries.cpp

@@ -3776,7 +3776,7 @@ static bool resolveFnCallSpecial(Context* context,
     if (ci.numActuals() == 2 || ci.hasQuestionArg()) {
       auto lhs = ci.actual(0).type();
 
-      // support comparisions with '?'
+      // support comparisons with '?'
       auto rhs = ci.hasQuestionArg() ?
                    QualifiedType(QualifiedType::TYPE, AnyType::get(context)) :
                    ci.actual(1).type();

frontend/lib/resolution/resolution-types.cpp

@@ -773,12 +773,12 @@ bool FormalActualMap::computeAlignment(const UntypedFnSignature* untyped,
 }
 
 static bool
-syncaticallyGenericFieldsPriorToIdHaveSubs(Context* context,
+syntacticallyGenericFieldsPriorToIdHaveSubs(Context* context,
                                            const CompositeType* ct,
                                            ID fieldId) {
   if (auto bct = ct->toBasicClassType()) {
     if (auto parentCt = bct->parentClassType()) {
-      if (!syncaticallyGenericFieldsPriorToIdHaveSubs(context, parentCt, fieldId)) {
+      if (!syntacticallyGenericFieldsPriorToIdHaveSubs(context, parentCt, fieldId)) {
         return false;
       }
     }
@@ -822,7 +822,7 @@ void ResolvedFields::validateFieldGenericity(Context* context, const types::Comp
     return;
   }
 
-  if (!syncaticallyGenericFieldsPriorToIdHaveSubs(context, fieldsOfType,
+  if (!syntacticallyGenericFieldsPriorToIdHaveSubs(context, fieldsOfType,
                                                   fields_[0].declId)) {
     return;
   }

frontend/lib/resolution/scope-queries.cpp

@@ -3159,7 +3159,7 @@ void GatherMentionedModules::gatherModuleId(const ID& id) {
   if (parsing::idIsModule(context, id)) {
     auto p = idSet.insert(id);
     if (p.second) {
-      // insertion occured, so add it also to the vector
+      // insertion occurred, so add it also to the vector
       idVec.push_back(id);
     }
   }
@@ -3311,7 +3311,7 @@ void GatherMentionedModules::processUseImport(const AstNode* ast) {
   if (scope && scope->containsUseImport()) {
     auto p = scopes.insert(scope);
     if (p.second) {
-      // Insertion occured, so this is the first time visiting this scope.
+      // Insertion occurred, so this is the first time visiting this scope.
       // Gather the IDs of the used/imported modules
       const ResolvedVisibilityScope* r = resolveVisibilityStmts(context, scope);
       if (r != nullptr) {

modules/dists/DSIUtil.chpl

@@ -649,7 +649,7 @@ proc bulkCommTranslateDomain(srcSlice : domain, srcDom : domain, targetDom : dom
 
 // this is an overload for views that are ranges. This will be used by code
 // paths that comes from elided array views. We could consider using this
-// lighterweight implementation as a more general special case for 1D bulk
+// lighter weight implementation as a more general special case for 1D bulk
 // transfers.
 proc bulkCommTranslateDomain(srcSlice : domain, srcView : range(?),
                              targetView : range(?)) {

modules/internal/ChapelArrayViewElision.chpl

@@ -71,7 +71,7 @@ module ChapelArrayViewElision {
   proc chpl__ave_exprCanBeProtoSlice(base, idxExprs...) param: bool {
     return chpl__ave_baseTypeSupports(base) &&
            chpl__ave_idxExprsSupport(base.idxType, (...idxExprs)) &&
-           !chpl__ave_nonComplientSlice(base, (...idxExprs));
+           !chpl__ave_nonCompliantSlice(base, (...idxExprs));
   }
 
   proc chpl__ave_protoSlicesSupportAssignment(a: chpl__protoSlice,
@@ -408,14 +408,14 @@ module ChapelArrayViewElision {
     return true;
   }
 
-  private proc chpl__ave_nonComplientSlice(base, idxExprs: domain) param {
-    // distributed array sliced with a distributed domain is non-complient
+  private proc chpl__ave_nonCompliantSlice(base, idxExprs: domain) param {
+    // distributed array sliced with a distributed domain is non-compliant.
     // such slices imply "redistribution" of the data. Right now, let's ignore
     // those
     return !chpl__isDROrDRView(base) && !chpl__isDROrDRView(idxExprs);
   }
 
-  private proc chpl__ave_nonComplientSlice(base, idxExprs...) param {
+  private proc chpl__ave_nonCompliantSlice(base, idxExprs...) param {
     return false;
   }
 

modules/internal/ChapelDomain.chpl

@@ -3116,15 +3116,15 @@ module ChapelDomain {
                        (if high(0).type == low.type then high(0).type else (low + high(0)).type);
       var ranges: size*range(eltType);
       if isTuple(low) {
-        if !isHomogeneousTuple(low) then compilerError("Domains defined using tuple bounds must use homogenous tuples, but got '" + low.type:string + "'");
+        if !isHomogeneousTuple(low) then compilerError("Domains defined using tuple bounds must use homogeneous tuples, but got '" + low.type:string + "'");
         for param i in 0..<size {
           if inclusive then
             ranges[i] = low[i]..high;
           else
             ranges[i] = low[i]..<high;
         }
       } else {
-        if !isHomogeneousTuple(high) then compilerError("Domains defined using tuple bounds must use homogenous tuples, but got '" + high.type:string + "'");
+        if !isHomogeneousTuple(high) then compilerError("Domains defined using tuple bounds must use homogeneous tuples, but got '" + high.type:string + "'");
         for param i in 0..<size {
           if inclusive then
             ranges[i] = low..high[i];
@@ -3142,7 +3142,7 @@ module ChapelDomain {
     where isTuple(low) && isTuple(high)
   {
     if !isHomogeneousTuple(low) || !isHomogeneousTuple(high) then
-      compilerError("Domains defined using tuple bounds must use homogenous tuples, but got '" +
+      compilerError("Domains defined using tuple bounds must use homogeneous tuples, but got '" +
                     low.type:string + "' and '" + high.type:string + "'");
     else if low.size != high.size then
       compilerError("Domains defined using tuple bounds must use tuples of the same length, " +