Fix various spelling errors.

Misspellings of:
* a..z (the English alphabet sequence a..z with one pair of letters transposed)
* actual
* algorithm
* amount
* although
* argument
* array
* as
* assignment
* auxiliary
* availability
* avoiding
* because
* beginning
* built
* canonicalization
* canonical
* catch
* causes
* collection
* committed
* compare
* comparison
* compilation
* completed
* concurrent
* conditions
* constructor
* contain
* context
* contiguous
* conversion
* convert
* corresponding
* counterparts
* coverage
* covered
* current
* declaration
* default
* deferred
* delimiters
* dependencies
* descriptions
* descriptor
* diagonal
* dictionary
* differently
* different
* disposed
* dynamically
* dynamic
* earlier
* emitting
* empty
* emulated
* encodable
* enough
* entrypoint
* enumerable
* environment
* evaluate
* everything
* exactly
* exception
* exercised
* existing
* expandos
* explicitly
* extension
* floatarray
* for-in
* foreign
* function
* generate
* generator
* granularity
* identical
* implemented
* implicit
* inclusive
* index
* indicate
* indicating
* infinity
* initializer
* initial
* injection
* inlinable
* inline
* insertion
* instance
* instantiate
* interior
* interpreter
* interpret
* invalidation
* invoke
* iterable
* iterator
* javascript
* label
* lambda
* lane
* language
* left
* length
* manager
* maximum
* member
* memory
* message
* metadata
* necessarily
* occurrence
* offset
* offsets
* of lit (two word sequence)
* ofobj
* ofreturn
* optimization
* original
* outer
* output
* overridable
* overridden
* owning
* parameter
* participate
* perlargest
* physical
* pollute
* polyfill
* polymorphic
* popping
* possibility
* preceded
* precise
* precision
* preferenced
* primitive
* processed
* profiled
* profile
* program
* progress
* propagate
* prop'd
* properties
* property
* prototype
* recycler
* re-enable
* referenceable
* reference
* registers
* removed
* required
* result
* semantics
* semicolon
* separately
* separator
* sequences
* should
* sibling
* signature
* similar
* simultaneously
* source
* sources
* spec'd
* specialization
* statement
* store
* straight
* subtags
* succeed
* successful
* sufficient
* summation
* supplied
* supported
* support
* surrogate
* telemetry
* ternary
* testing
* then
* the
* though
* threshold
* timing
* transferred
* traversal
* truncation
* typespec'd
* underflow
* uninitialized
* unknown
* unless
* unregister
* unroll
* unscopable
* using
* value
* variable
* verifies
* verify
* visitor
* without
* zero

Proper noun:
* ForceES5Array

Grammar:
* a/an
* any one of the ... is
* as an input/output
* because
* be replaced
* different thresholds
* have
* is
* is a
* it is
* lossless
* not to report
* operations
* required by
* the
* true
* a tortured sentence involving interleaving

Tagging an ambiguous token with a guess
* pronunciation

Whitespace

Build/Chakra.Build.props

@@ -29,8 +29,8 @@
         %(DisableSpecificWarnings);
         4456;     <!-- declaration of '' hides previous local declaration -->
         4457;     <!-- declaration of '' hides function parameter -->
-        4458;     <!-- declaration of '' hides class memeber -->
-        4091;     <!-- '': ignore on lef of 'type' when no variable is declared -->
+        4458;     <!-- declaration of '' hides class member -->
+        4091;     <!-- '': ignore on left of 'type' when no variable is declared -->
         4838;     <!-- conversion from 'unsigned int' to 'int requires a narrowing conversion -->
         4499;     <!-- explicit specialization cannot have a storage class (ignored) -->
         4463;     <!-- overflow; assigning 1 to bit-field that can only hold values from -1 to 0 -->
@@ -45,12 +45,12 @@
         %(AdditionalIncludeDirectories)
       </AdditionalIncludeDirectories>
 
-      <!-- ======== For Code Covearge ======== -->
+      <!-- ======== For Code Coverage ======== -->
       <Optimization Condition="'$(ENABLE_CODECOVERAGE)'=='true'">Disabled</Optimization>
     </ClCompile>
 
     <Link>
-      <!-- ======== For Code Covearge ======== -->
+      <!-- ======== For Code Coverage ======== -->
       <AdditionalOptions Condition="'$(ENABLE_CODECOVERAGE)'=='true'">%(AdditionalOptions) /DEBUGTYPE:CV,FIXUP</AdditionalOptions>
     </Link>
   </ItemDefinitionGroup>

Build/scripts/post_build.ps1

@@ -43,7 +43,7 @@ if ($arch -eq "*") {
     }
 
 } else {
-    $OutterScriptRoot = $PSScriptRoot;
+    $OuterScriptRoot = $PSScriptRoot;
     . "$PSScriptRoot\pre_post_util.ps1"
 
     if (($logFile -eq "") -and (Test-Path Env:\TF_BUILD_BINARIESDIRECTORY)) {

Build/scripts/pre_build.ps1

@@ -34,7 +34,7 @@ param (
     [string]$oauth
 )
 
-$OutterScriptRoot = $PSScriptRoot;
+$OuterScriptRoot = $PSScriptRoot;
 . "$PSScriptRoot\pre_post_util.ps1"
 if (($logFile -eq "") -and (Test-Path Env:\TF_BUILD_BINARIESDIRECTORY)) {
     if (-not(Test-Path -Path "$Env:TF_BUILD_BINARIESDIRECTORY\logs")) {

Build/scripts/pre_post_util.ps1

@@ -33,7 +33,7 @@ function GetGitPath()
     return $gitExe;
 }
 
-$srcpath = UseValueOrDefault $srcpath "$env:TF_BUILD_SOURCESDIRECTORY" (Resolve-Path "$OutterScriptRoot\..\..");
+$srcpath = UseValueOrDefault $srcpath "$env:TF_BUILD_SOURCESDIRECTORY" (Resolve-Path "$OuterScriptRoot\..\..");
 $binpath = UseValueOrDefault $binpath "$env:TF_BUILD_BINARIESDIRECTORY" "$srcpath\Build\VcBuild\bin\$arch_$flavor";
 $objpath = UseValueOrDefault $objpath "$env:TF_BUILD_BUILDDIRECTORY" "$srcpath\Build\VcBuild\obj\$arch_$flavor";
 

bin/rl/rl.h

@@ -99,7 +99,7 @@ extern TARGET_OS TargetOS;
 #define CFG_ERROR_EX(file,line,fmt,args) fprintf(stderr, "Error: %s(%d) - " ##fmt "\n", file, line, args)
 #define CFG_WARNING_EX(file,line,fmt,args) do { if (!FQuiet) printf("Warning: %s(%d) - " ##fmt "\n", file, line, (args)); } while (0)
 
-// Parsing delimeters
+// Parsing delimiters
 
 #define OPT_DELIM " \t"
 #define XML_DELIM ","

bin/rl/rlregr.cpp

@@ -12,7 +12,7 @@
 
 #define TMP_PREFIX "di"   // 2 characters
 
-// Currently not overrideable
+// Currently not overridable
 #define REGR_PERL "perl"
 
 #define DIR_START_CMD "startdir.cmd"

bin/rl/xmlreader.cpp

@@ -366,7 +366,7 @@ CreateStreamOnHandle
    // an IStream object that reads a file lazily. Rather than writing our own
    // IStream implementation that does this, we just read the whole file here
    // given that XML files don't get quite large and it should be okay to keep
-   // everyting in memory.
+   // everything in memory.
 
    DWORD fileSize, fileSizeHigh, bytesRead;
    HGLOBAL buffer;

jenkins.check_copyright.py

@@ -26,7 +26,7 @@ if len(sys.argv) < 2:
 
 file_name = sys.argv[1]
 if not os.path.isfile(file_name):
-    print "File does not exist:", file_name, "(not neccesarily an error)"
+    print "File does not exist:", file_name, "(not necessarily an error)"
     exit(0)
 
 with open(file_name, 'r') as sourcefile:

lib/Backend/BackwardPass.cpp

@@ -29,7 +29,7 @@ BackwardPass::BackwardPass(Func * func, GlobOpt * globOpt, Js::Phase tag)
 #if DBG_DUMP
     this->numDeadStore = 0;
     this->numMarkTempNumber = 0;
-    this->numMarkTempNumberTransfered = 0;
+    this->numMarkTempNumberTransferred = 0;
     this->numMarkTempObject = 0;
 #endif
 }
@@ -86,7 +86,7 @@ BackwardPass::DoMarkTempObjects() const
 
     // Why MarkTempObject is disabled under debugger:
     //   We add 'identified so far dead non-temp locals' to byteCodeUpwardExposedUsed in ProcessBailOutInfo,
-    //   this may cause MarkTempObject to convert some temps back to non-temp when it sees a 'transfered exposed use'
+    //   this may cause MarkTempObject to convert some temps back to non-temp when it sees a 'transferred exposed use'
     //   from a temp to non-temp. That's in general not a supported conversion (while non-temp -> temp is fine).
 }
 
@@ -323,16 +323,16 @@ BackwardPass::Optimize()
         Output::Print(this->tag == Js::BackwardPhase? L"Backward Phase Stats:\n" : L"Deadstore Phase Stats:\n");
         if (this->DoDeadStore())
         {
-            Output::Print(L"  Deadstore             : %3d\n", this->numDeadStore);
+            Output::Print(L"  Deadstore              : %3d\n", this->numDeadStore);
         }
         if (this->DoMarkTempNumbers())
         {
-            Output::Print(L"  Temp Number           : %3d\n", this->numMarkTempNumber);
-            Output::Print(L"  Transfered Temp Number: %3d\n", this->numMarkTempNumberTransfered);
+            Output::Print(L"  Temp Number            : %3d\n", this->numMarkTempNumber);
+            Output::Print(L"  Transferred Temp Number: %3d\n", this->numMarkTempNumberTransferred);
         }
         if (this->DoMarkTempObjects())
         {
-            Output::Print(L"  Temp Object           : %3d\n", this->numMarkTempObject);
+            Output::Print(L"  Temp Object            : %3d\n", this->numMarkTempObject);
         }
     }
 #endif
@@ -5696,7 +5696,7 @@ BackwardPass::TransferCompoundedAddSubUsesToSrcs(IR::Instr *const instr, const i
 
         if(intOverflowDoesNotMatterInRangeBySymId->Test(srcSym->m_id))
         {
-            // Since an src may be compounded through different chains of add/sub instructions, the greater number must be
+            // Since a src may be compounded through different chains of add/sub instructions, the greater number must be
             // preserved
             srcSym->scratch.globOpt.numCompoundedAddSubUses =
                 max(srcSym->scratch.globOpt.numCompoundedAddSubUses, addSubUses);

lib/Backend/BackwardPass.h

@@ -225,7 +225,7 @@ private:
 #if DBG_DUMP
     uint32 numDeadStore;
     uint32 numMarkTempNumber;
-    uint32 numMarkTempNumberTransfered;
+    uint32 numMarkTempNumberTransferred;
     uint32 numMarkTempObject;
 #endif
 

lib/Backend/BailOut.cpp

@@ -765,7 +765,7 @@ BailOutRecord::RestoreValue(IR::BailOutKind bailOutKind, Js::JavascriptCallStack
             //      bar(a, b, c);
             // } catch(..) {..}
             // and we bailout during bar args evaluation, we recover from args from argoutRestoreAddress, not from caller function frame.
-            // This is beceause try-catch is implemented as a C wrapper, so args will be a different offset from rbp in that case.
+            // This is because try-catch is implemented as a C wrapper, so args will be a different offset from rbp in that case.
             Assert(!isFloat64 && !isInt32 && !isSimd128F4 && !isSimd128I4);
 
             value = *((Js::Var *)(((char *)argoutRestoreAddress) + regSlot * MachPtr));
@@ -1579,7 +1579,7 @@ BailOutRecord::BailOutHelper(Js::JavascriptCallStackLayout * layout, Js::ScriptF
 //
 // To avoid always incurring the cost of collecting runtime stats (function calls count and valid bailOutKind),
 // the initial codegen'd version of a function does not collect them. After a second bailout we rejit the function
-// with runtime stats collection. On subsequent bailouts we can evaulate our heuristics and decide whether to rejit.
+// with runtime stats collection. On subsequent bailouts we can evaluate our heuristics and decide whether to rejit.
 //
 // Function bodies always use the least optimized version of the code as default. At the same time, there can be
 // function objects with some older, more optimized, version of the code active. When a bailout occurs out of such
@@ -2099,7 +2099,7 @@ void BailOutRecord::ScheduleFunctionCodeGen(Js::ScriptFunction * function, Js::S
 
 // To avoid always incurring the cost of collecting runtime stats (valid bailOutKind),
 // the initial codegen'd version of a loop body does not collect them. After a second bailout we rejit the body
-// with runtime stats collection. On subsequent bailouts we can evaulate our heuristics.
+// with runtime stats collection. On subsequent bailouts we can evaluate our heuristics.
 void BailOutRecord::ScheduleLoopBodyCodeGen(Js::ScriptFunction * function, Js::ScriptFunction * innerMostInlinee, BailOutRecord const * bailOutRecord, IR::BailOutKind bailOutKind)
 {
     Assert(bailOutKind != IR::LazyBailOut);

lib/Backend/BailOut.h

@@ -116,7 +116,7 @@ public:
     // The actual bailout instr, this is normally the instr that has the bailout info.
     // 1) If we haven't generated bailout (which happens in lowerer) for this bailout info, this is either of:
     // - the instr that has bailout info.
-    // - in case of shared bailout this will be the BailTarget instr (corresponds to the call to SaveReesgtersAndBailOut,
+    // - in case of shared bailout this will be the BailTarget instr (corresponds to the call to SaveRegistersAndBailOut,
     //   while other instrs sharing bailout info will just have checks and JMP to BailTarget).
     // 2) After we generated bailout, this becomes label instr. In case of shared bailout other instrs JMP to this label.
     IR::Instr * bailOutInstr;

lib/Backend/BailOutKind.h

@@ -63,15 +63,15 @@ BAIL_OUT_KIND(BailOutKindBitsStart, 0) // fake bail out kind to indicate start i
 // ======================
 // Result condition bits
 // ======================
-#define BAIL_OUT_KIND_RESULT_CONDITONS_BIT_START BAIL_OUT_KIND_BIT_START
-BAIL_OUT_KIND_VALUE(BailOutOnOverflow, 1 << (BAIL_OUT_KIND_RESULT_CONDITONS_BIT_START + 0))
-BAIL_OUT_KIND_VALUE(BailOutOnMulOverflow, 1 << (BAIL_OUT_KIND_RESULT_CONDITONS_BIT_START + 1))
-BAIL_OUT_KIND_VALUE(BailOutOnNegativeZero, 1 << (BAIL_OUT_KIND_RESULT_CONDITONS_BIT_START + 2))
+#define BAIL_OUT_KIND_RESULT_CONDITIONS_BIT_START BAIL_OUT_KIND_BIT_START
+BAIL_OUT_KIND_VALUE(BailOutOnOverflow, 1 << (BAIL_OUT_KIND_RESULT_CONDITIONS_BIT_START + 0))
+BAIL_OUT_KIND_VALUE(BailOutOnMulOverflow, 1 << (BAIL_OUT_KIND_RESULT_CONDITIONS_BIT_START + 1))
+BAIL_OUT_KIND_VALUE(BailOutOnNegativeZero, 1 << (BAIL_OUT_KIND_RESULT_CONDITIONS_BIT_START + 2))
 BAIL_OUT_KIND_VALUE(BailOutOnResultConditions, BailOutOnOverflow | BailOutOnMulOverflow | BailOutOnNegativeZero)
 // ================
 // Array bits
 // ================
-#define BAIL_OUT_KIND_ARRAY_BIT_START BAIL_OUT_KIND_RESULT_CONDITONS_BIT_START + 3
+#define BAIL_OUT_KIND_ARRAY_BIT_START BAIL_OUT_KIND_RESULT_CONDITIONS_BIT_START + 3
 BAIL_OUT_KIND_VALUE(BailOutOnMissingValue, 1 << (BAIL_OUT_KIND_ARRAY_BIT_START + 0))
 BAIL_OUT_KIND_VALUE(BailOutConventionalNativeArrayAccessOnly, 1 << (BAIL_OUT_KIND_ARRAY_BIT_START + 1))
 BAIL_OUT_KIND_VALUE(BailOutConvertedNativeArray, 1 << (BAIL_OUT_KIND_ARRAY_BIT_START + 2))

lib/Backend/CodeGenWorkItem.cpp

@@ -76,10 +76,10 @@ bool CodeGenWorkItem::ShouldSpeculativelyJitBasedOnProfile() const
     Js::FunctionBody* functionBody = this->GetFunctionBody();
 
     uint loopPercentage = (functionBody->GetByteCodeInLoopCount()*100) / (functionBody->GetByteCodeCount() + 1);
-    uint straighLineSize = functionBody->GetByteCodeCount() - functionBody->GetByteCodeInLoopCount();
+    uint straightLineSize = functionBody->GetByteCodeCount() - functionBody->GetByteCodeInLoopCount();
 
     // This ensures only small and loopy functions are prejitted.
-    if(loopPercentage >= 50 || straighLineSize < 300)
+    if(loopPercentage >= 50 || straightLineSize < 300)
     {
         Js::SourceDynamicProfileManager* profileManager = functionBody->GetSourceContextInfo()->sourceDynamicProfileManager;
         if(profileManager != nullptr)

lib/Backend/FlowGraph.cpp

@@ -650,7 +650,7 @@ FlowGraph::CanonicalizeLoops()
     }
 
 #if DBG_DUMP
-    this->Dump(true, L"\n Before cannonicalizeLoops \n");
+    this->Dump(true, L"\n Before canonicalizeLoops \n");
 #endif
 
     bool breakBlockRelocated = false;
@@ -669,7 +669,7 @@ FlowGraph::CanonicalizeLoops()
     }
 
 #if DBG_DUMP
-    this->Dump(true, L"\n After cannonicalizeLoops \n");
+    this->Dump(true, L"\n After canonicalizeLoops \n");
 #endif
 
     return breakBlockRelocated;

lib/Backend/FlowGraph.h

@@ -665,8 +665,8 @@ public:
         BVSparse<JitArenaAllocator> *inductionVariablesUsedAfterLoop;
         InductionVariableChangeInfoMap *inductionVariableChangeInfoMap;
         InductionVariableOpndPerUnrollMap *inductionVariableOpndPerUnrollMap;
-        // This assumes that all memop operation use the same index and has the same length
-        // Temporary map to reuse existing startIndexOpnd while emiting
+        // This assumes that all memop operations use the same index and have the same length
+        // Temporary map to reuse existing startIndexOpnd while emitting
         // 0 = !increment & !alreadyChanged, 1 = !increment & alreadyChanged, 2 = increment & !alreadyChanged, 3 = increment & alreadyChanged
         IR::RegOpnd* startIndexOpndCache[4];
     } MemOpInfo;

lib/Backend/Func.h

@@ -195,7 +195,7 @@ static const unsigned __int64 c_debugFillPattern8 = 0xcececececececece;
 #elif defined(_M_X64) || defined(_M_ARM64)
     static const unsigned __int64 c_debugFillPattern = c_debugFillPattern8;
 #else
-#error unsuported platform
+#error unsupported platform
 #endif
 
 #endif

lib/Backend/GlobOpt.cpp

@@ -2305,7 +2305,7 @@ GlobOpt::ToTypeSpec(BVSparse<JitArenaAllocator> *bv, BasicBlock *block, IRType t
 
         // Win8 bug: 757126. If we are trying to type specialize the arguments object,
         // let's make sure stack args optimization is not enabled. This is a problem, particularly,
-        // if the instruction comes from a unreachable block. In other cases, the pass on the
+        // if the instruction comes from an unreachable block. In other cases, the pass on the
         // instruction itself should disable arguments object optimization.
         if(block->globOptData.argObjSyms && IsArgumentsSymID(id, block->globOptData))
         {
@@ -2433,7 +2433,7 @@ GlobOpt::CleanUpValueMaps()
                         deadSymsBv.Set(bucket.value->m_id);
 
                         // Make sure the type sym is added to the dead syms vector as well, because type syms are
-                        // created in backward pass and so their symIds > maxIntitialSymID.
+                        // created in backward pass and so their symIds > maxInitialSymID.
                         if (sym->IsStackSym() && sym->AsStackSym()->HasObjectTypeSym())
                         {
                             deadSymsBv.Set(sym->AsStackSym()->GetObjectTypeSym()->m_id);
@@ -2444,7 +2444,7 @@ GlobOpt::CleanUpValueMaps()
                 else
                 {
                     // Make sure the type sym is added to the dead syms vector as well, because type syms are
-                    // created in backward pass and so their symIds > maxIntitialSymID. Perhaps we could remove
+                    // created in backward pass and so their symIds > maxInitialSymID. Perhaps we could remove
                     // it explicitly here, but would it work alright with the iterator?
                     if (sym->IsStackSym() && sym->AsStackSym()->HasObjectTypeSym())
                     {
@@ -4156,7 +4156,7 @@ GlobOpt::IsAllowedForMemOpt(IR::Instr* instr, bool isMemset, IR::RegOpnd *baseOp
     const InductionVariable* iv = GetInductionVariable(indexSymID, loop);
     if (!iv)
     {
-        // If the index is not a induction variable return
+        // If the index is not an induction variable return
         TRACE_MEMOP_VERBOSE(loop, instr, L"Index (s%d) is not an induction variable", indexSymID);
         return false;
     }
@@ -7010,7 +7010,7 @@ GlobOpt::ValueNumberDst(IR::Instr **pInstr, Value *src1Val, Value *src2Val)
             "Creator of this instruction should have set the type");
         // fall-through
     case Js::OpCode::Coerse_StrOrRegex:
-        // We don't set the ValyueType of src1 for Coerse_StrOrRegex, hence skip the ASSERT
+        // We don't set the ValueType of src1 for Coerse_StrOrRegex, hence skip the ASSERT
         if (this->IsLoopPrePass() || src1ValueInfo == nullptr || !src1ValueInfo->IsString())
         {
             break;
@@ -7138,7 +7138,7 @@ GlobOpt::ValueNumberDst(IR::Instr **pInstr, Value *src1Val, Value *src2Val)
         if(!this->IsLoopPrePass())
         {
             // We cannot transfer value if the field hasn't been copy prop'd because we don't generate
-            // an implicit call bailout between those values if we don't have "live fields" unnless, we are hoisting the field.
+            // an implicit call bailout between those values if we don't have "live fields" unless, we are hoisting the field.
             PropertySym *propertySym = instr->GetSrc1()->AsSymOpnd()->m_sym->AsPropertySym();
             StackSym * fieldHoistSym;
             Loop * loop = this->FindFieldHoistStackSym(this->currentBlock->loop, propertySym->m_id, &fieldHoistSym, instr);
@@ -9612,7 +9612,7 @@ GlobOpt::TypeSpecializeInlineBuiltInBinary(IR::Instr **pInstr, Value *src1Val, V
                 }
                 // Type specialize to int
                 bool retVal = this->TypeSpecializeIntBinary(pInstr, src1Val, src2Val, pDstVal, newMin, newMax, false /* skipDst */);
-                AssertMsg(retVal, "For min and max, the args have to be type-specialized to int if any both of the srces are int, but something failed during the process.");
+                AssertMsg(retVal, "For min and max, the args have to be type-specialized to int if any one of the sources is an int, but something failed during the process.");
             }
 
             // Couldn't type specialize to int, type specialize to float
@@ -9622,7 +9622,7 @@ GlobOpt::TypeSpecializeInlineBuiltInBinary(IR::Instr **pInstr, Value *src1Val, V
                 src1Val = src1OriginalVal;
                 src2Val = src2OriginalVal;
                 bool retVal = this->TypeSpecializeFloatBinary(instr, src1Val, src2Val, pDstVal);
-                AssertMsg(retVal, "For min and max, the args have to be type-specialized to float if any one of the src is a float, but something failed during the process.");
+                AssertMsg(retVal, "For min and max, the args have to be type-specialized to float if any one of the sources is a float, but something failed during the process.");
             }
             break;
         }
@@ -9727,7 +9727,7 @@ GlobOpt::TypeSpecializeIntBinary(IR::Instr **pInstr, Value *src1Val, Value *src2
                 isIntConstMissingItem = Js::SparseArraySegment<int>::IsMissingItem(&intConstantValue);
             }
 
-            // Don't specialize if the element is not likelyInt or a IntConst which is a missing item value.
+            // Don't specialize if the element is not likelyInt or an IntConst which is a missing item value.
             if(!(src2Val->GetValueInfo()->IsLikelyInt()) || isIntConstMissingItem)
             {
                 return false;
@@ -10073,7 +10073,7 @@ GlobOpt::TypeSpecializeIntUnary(
             StackSym *sym = instr->GetSrc1()->AsRegOpnd()->m_sym;
             if (this->IsInt32TypeSpecialized(sym, this->currentBlock) == false)
             {
-                // Type specializing an BrTrue_A/BrFalse_A isn't worth it, unless the src
+                // Type specializing a BrTrue_A/BrFalse_A isn't worth it, unless the src
                 // is already type specialized
                 specialize = false;
             }
@@ -11845,7 +11845,7 @@ GlobOpt::IsWorthSpecializingToInt32Branch(IR::Instr * instr, Value * src1Val, Va
                 StackSym *sym = instr->GetSrc2()->AsRegOpnd()->m_sym;
                 if (this->IsInt32TypeSpecialized(sym, this->currentBlock) == false)
                 {
-                    // Type specializing an Br itself isn't worth it, unless one src
+                    // Type specializing a Br itself isn't worth it, unless one src
                     // is already type specialized
                     return false;
                 }
@@ -17015,7 +17015,7 @@ GlobOpt::OptArraySrc(IR::Instr * *const instrRef)
         // benefit much from the no-missing-values information, it may be beneficial to avoid checking for no missing
         // values, especially in the case for a single array access, where the cost of the check could be relatively
         // significant. An StElem has to do additional checks in the common path if the array may have missing values, and
-        // an StElem that operates on an array that has no missing values is more likely to keep the no-missing-values info
+        // a StElem that operates on an array that has no missing values is more likely to keep the no-missing-values info
         // on the array more precise, so it still benefits a little from the no-missing-values info.
         CaptureNoImplicitCallUses(baseOpnd, isLoad || isStore);
     }
@@ -20459,7 +20459,7 @@ GlobOpt::KillStateForGeneratorYield()
     GlobOptBlockData* globOptData = &this->currentBlock->globOptData;
 
     /*
-    TODO[generators][ianhall]: Do a ToVar on any typespec'ed syms before the bailout so that we can enable typespec in generators without bailin having to restore typespec'ed values
+    TODO[generators][ianhall]: Do a ToVar on any typespec'd syms before the bailout so that we can enable typespec in generators without bailin having to restore typespec'd values
     FOREACH_BITSET_IN_SPARSEBV(symId, globOptData->liveInt32Syms)
     {
         this->ToVar(instr, , this->currentBlock, , );

lib/Backend/GlobOptBailout.cpp

@@ -362,7 +362,7 @@ GlobOpt::TrackCalls(IR::Instr * instr)
     case Js::OpCode::InlineThrow:
     case Js::OpCode::InlineRuntimeTypeError:
     case Js::OpCode::InlineRuntimeReferenceError:
-        //We are not going to see an  inlinee end
+        //We are not going to see an inlinee end
         this->func->UpdateMaxInlineeArgOutCount(this->currentBlock->globOptData.inlinedArgOutCount);
         break;
 

lib/Backend/GlobOptSimd128.cpp

@@ -93,7 +93,7 @@ Value **pDstVal
         instr->m_func->GetScriptContext()->GetThreadContext()->GetSimdFuncSignatureFromOpcode(instr->m_opcode, simdFuncSignature);
         // type-spec logic
 
-        // special handling for load/sotre
+        // special handling for load/store
         // OptArraySrc will type-spec the array and the index. We type-spec the value here.
         if (Js::IsSimd128Load(instr->m_opcode))
         {
@@ -305,7 +305,7 @@ GlobOpt::Simd128DoTypeSpecLoadStore(IR::Instr *instr, const Value *src1Val, cons
         indexOpnd = instr->GetDst()->AsIndirOpnd()->GetIndexOpnd();
         valueOpnd = instr->GetSrc1();
 
-        // St(arr, index, value). Make sure value can be Simd128 type-spec'ed
+        // St(arr, index, value). Make sure value can be Simd128 type-spec'd
         doTypeSpec = doTypeSpec && Simd128CanTypeSpecOpnd(FindValue(valueOpnd->AsRegOpnd()->m_sym)->GetValueInfo()->Type(), simdFuncSignature->args[2]);
     }
     else
@@ -406,7 +406,7 @@ bool GlobOpt::Simd128ValidateIfLaneIndex(const IR::Instr * instr, IR::Opnd * opn
         return true; // not a lane index
     }
 
-    // arg in lanex index pos of operation ?
+    // arg in lane index pos of operation ?
     if (argPos < argPosLo || argPos > argPosHi)
     {
         return true; // not a lane index
@@ -414,7 +414,7 @@ bool GlobOpt::Simd128ValidateIfLaneIndex(const IR::Instr * instr, IR::Opnd * opn
 
     // It is a lane index ...
 
-    // Arg is Int constant (literal or const prop'ed) ?
+    // Arg is Int constant (literal or const prop'd) ?
     if (!opnd->IsIntConstOpnd())
     {
         return false;

lib/Backend/IR.cpp

@@ -2978,7 +2978,7 @@ Instr::ConvertToBailOutInstr(BailOutInfo * bailOutInfo, IR::BailOutKind kind, bo
     if (this->HasAuxBailOut())
     {
         // This instr has already been converted to bailout instr. Only possible with aux bail out.
-        // Typical scenario is when globopt calls to convert to e.g. BailOutOnImplcitCalls for the instr which
+        // Typical scenario is when globopt calls to convert to e.g. BailOutOnImplicitCalls for the instr which
         // was already converted to bail out instr with HasBailOutInfo() == false and HasAuxBailOutInfo() == true,
         // so that aux bail out is hidden in between IRBuilder and lowerer.
 
@@ -3662,7 +3662,7 @@ bool Instr::BinaryCalculator(IntConstType src1Const, IntConstType src2Const, Int
         IntConstMath::ShrU(src1Const, src2Const & 0x1F, &value);
         if (value < 0)
         {
-            // ShrU produces a UInt32.  If it doesn't fit in a Int32, bail as we don't
+            // ShrU produces a UInt32.  If it doesn't fit in an Int32, bail as we don't
             // track signs of int values.
             return false;
         }

lib/Backend/IR.inl

@@ -28,7 +28,7 @@ Instr::IsEntryInstr() const
 ///
 /// Instr::AsEntryInstr
 ///
-///     Return this as a EntryInstr *
+///     Return this as an EntryInstr *
 ///
 ///----------------------------------------------------------------------------
 
@@ -56,7 +56,7 @@ Instr::IsExitInstr() const
 ///
 /// Instr::AsExitInstr
 ///
-///     Return this as a ExitInstr *
+///     Return this as an ExitInstr *
 ///
 ///----------------------------------------------------------------------------
 
@@ -196,7 +196,7 @@ Instr::IsProfiledLabelInstr() const
 inline ProfiledLabelInstr *
 Instr::AsProfiledLabelInstr()
 {
-    AssertMsg(this->IsProfiledLabelInstr(), "Bad call to AsProfiledlLabelInstr()");
+    AssertMsg(this->IsProfiledLabelInstr(), "Bad call to AsProfiledLabelInstr()");
 
     return reinterpret_cast<ProfiledLabelInstr *>(this);
 }

lib/Backend/IRBuilder.cpp

@@ -4586,7 +4586,7 @@ IRBuilder::BuildElementU(Js::OpCode newOpcode, uint32 offset, Js::RegSlot instan
 ///
 /// IRBuilder::BuildAuxiliary
 ///
-///     Build IR instr for a Auxiliary instruction.
+///     Build IR instr for an Auxiliary instruction.
 ///
 ///----------------------------------------------------------------------------
 
@@ -6663,7 +6663,7 @@ IRBuilder::EnsureConsumeBranchIsland()
             ConsumeBranchIsland();
 
             // Mark the virtual branch around as a redirect long branch as well
-            // so that if it is the target of a another branch, it will just keep pass
+            // so that if it is the target of another branch, it will just keep pass
             // the branch island
             Assert(longBranchMap);
             Assert(offset < m_offsetToInstructionCount);

lib/Backend/Inline.cpp

@@ -1961,7 +1961,7 @@ Inline::InlineBuiltInFunction(IR::Instr *callInstr, Js::FunctionInfo *funcInfo,
         inlineBuiltInEndInstr = InsertInlineeBuiltInStartEndTags(callInstr, actualCount);
 
         // InlineArrayPop - TrackCalls Need to be done at InlineArrayPop and not at the InlineBuiltInEnd
-        // Hence we use a new opcode, to detect that it is a InlineArrayPop and we don't track the call during End of inlineBuiltInCall sequence
+        // Hence we use a new opcode, to detect that it is an InlineArrayPop and we don't track the call during End of inlineBuiltInCall sequence
         if(inlineCallOpCode == Js::OpCode::InlineArrayPop)
         {
             inlineBuiltInEndInstr->m_opcode = Js::OpCode::InlineNonTrackingBuiltInEnd;
@@ -1980,10 +1980,10 @@ Inline::InlineBuiltInFunction(IR::Instr *callInstr, Js::FunctionInfo *funcInfo,
         )
     {
         // Emit byteCodeUses for function object
-        IR::Instr * inlineBuilitInStartInstr = inlineBuiltInEndInstr;
-        while(inlineBuilitInStartInstr->m_opcode != Js::OpCode::InlineBuiltInStart)
+        IR::Instr * inlineBuiltInStartInstr = inlineBuiltInEndInstr;
+        while(inlineBuiltInStartInstr->m_opcode != Js::OpCode::InlineBuiltInStart)
         {
-            inlineBuilitInStartInstr = inlineBuilitInStartInstr->m_prev;
+            inlineBuiltInStartInstr = inlineBuiltInStartInstr->m_prev;
         }
 
         IR::Opnd * tmpDst = nullptr;
@@ -2033,7 +2033,7 @@ Inline::InlineBuiltInFunction(IR::Instr *callInstr, Js::FunctionInfo *funcInfo,
         IR::ByteCodeUsesInstr * byteCodeUsesInstr = IR::ByteCodeUsesInstr::New(callInstr->m_func);
         byteCodeUsesInstr->SetByteCodeOffset(callInstr);
         byteCodeUsesInstr->byteCodeUpwardExposedUsed = JitAnew(callInstr->m_func->m_alloc, BVSparse<JitArenaAllocator>, callInstr->m_func->m_alloc);
-        IR::Instr *argInsertInstr = inlineBuilitInStartInstr;
+        IR::Instr *argInsertInstr = inlineBuiltInStartInstr;
 
 // SIMD_JS
         IR::Instr *eaInsertInstr = callInstr;
@@ -2270,7 +2270,7 @@ IR::Instr* Inline::InlineApply(IR::Instr *callInstr, Js::FunctionInfo *funcInfo,
         }
         else
         {
-            INLINE_TESTTRACE(L"INLINING: Skip Inline: Supporting inlining func.apply(this, array) or func.apply(this, arguments) with formals in the parent function only when func is a built-in inlineable as apply target \tCaller: %s (%s)\n",
+            INLINE_TESTTRACE(L"INLINING: Skip Inline: Supporting inlining func.apply(this, array) or func.apply(this, arguments) with formals in the parent function only when func is a built-in inlinable as apply target \tCaller: %s (%s)\n",
                 inlinerData->GetFunctionBody()->GetDisplayName(), inlinerData->GetFunctionBody()->GetDebugNumberSet(debugStringBuffer));
             return callInstr;
         }

lib/Backend/InliningDecider.cpp

@@ -125,7 +125,7 @@ Js::FunctionInfo *InliningDecider::InlineCallSite(Js::FunctionBody *const inline
     return nullptr;
 }
 
-uint InliningDecider::InlinePolymorhicCallSite(Js::FunctionBody *const inliner, const Js::ProfileId profiledCallSiteId,
+uint InliningDecider::InlinePolymorphicCallSite(Js::FunctionBody *const inliner, const Js::ProfileId profiledCallSiteId,
     Js::FunctionBody** functionBodyArray, uint functionBodyArrayLength, bool* canInlineArray, uint recursiveInlineDepth)
 {
     Assert(inliner);

lib/Backend/InliningDecider.h

@@ -32,7 +32,7 @@ public:
     Js::FunctionInfo *GetCallSiteFuncInfo(Js::FunctionBody *const inliner, const Js::ProfileId profiledCallSiteId, bool* isConstructorCall, bool* isPolymorphicCall);
     uint16 GetConstantArgInfo(Js::FunctionBody *const inliner, const Js::ProfileId profiledCallSiteId);
     bool HasCallSiteInfo(Js::FunctionBody *const inliner, const Js::ProfileId profiledCallSiteId);
-    uint InlinePolymorhicCallSite(Js::FunctionBody *const inliner, const Js::ProfileId profiledCallSiteId, Js::FunctionBody** functionBodyArray, uint functionBodyArrayLength, bool* canInlineArray, uint recursiveInlineDepth = 0);
+    uint InlinePolymorphicCallSite(Js::FunctionBody *const inliner, const Js::ProfileId profiledCallSiteId, Js::FunctionBody** functionBodyArray, uint functionBodyArrayLength, bool* canInlineArray, uint recursiveInlineDepth = 0);
     bool GetIsLoopBody() { return isLoopBody;};
 
     void SetAggressiveHeuristics() { inliningHeuristics.threshold.SetAggressiveHeuristics(); }

lib/Backend/InterpreterThunkEmitter.cpp

@@ -549,12 +549,12 @@ DWORD InterpreterThunkEmitter::CopyWithAlignment(
 void InterpreterThunkEmitter::Close()
 {
 #if PDATA_ENABLED
-    auto unregiserPdata = ([&] (const ThunkBlock& block)
+    auto unregisterPdata = ([&] (const ThunkBlock& block)
     {
         PDataManager::UnregisterPdata((PRUNTIME_FUNCTION) block.GetPdata());
     });
-    thunkBlocks.Iterate(unregiserPdata);
-    freeListedThunkBlocks.Iterate(unregiserPdata);
+    thunkBlocks.Iterate(unregisterPdata);
+    freeListedThunkBlocks.Iterate(unregisterPdata);
 #endif
     this->thunkBlocks.Clear(allocator);
     this->freeListedThunkBlocks.Clear(allocator);

lib/Backend/LinearScan.cpp

@@ -793,7 +793,7 @@ LinearScan::SetDstReg(IR::Instr *instr)
 
     StackSym * stackSym = regOpnd->m_sym;
 
-    // Arg slot sym can be in an RegOpnd for param passed via registers
+    // Arg slot sym can be in a RegOpnd for param passed via registers
     // Just use the assigned register
     if (stackSym == nullptr || stackSym->IsArgSlotSym())
     {
@@ -2528,7 +2528,7 @@ LinearScan::FindReg(Lifetime *newLifetime, IR::RegOpnd *regOpnd, bool force)
                 BitVector regsBvTemp = regsBv;
                 regsBvTemp.And(this->calleeSavedRegs);
 
-                regIndex = GetPreferrencedRegIndex(newLifetime, regsBvTemp);
+                regIndex = GetPreferencedRegIndex(newLifetime, regsBvTemp);
 
                 if (regIndex == BVInvalidIndex)
                 {
@@ -2537,7 +2537,7 @@ LinearScan::FindReg(Lifetime *newLifetime, IR::RegOpnd *regOpnd, bool force)
                         // No callee saved regs is found and the lifetime only across helper
                         // calls, we can also use a caller saved regs to make use of the
                         // save and restore around helper blocks
-                        regIndex = GetPreferrencedRegIndex(newLifetime, regsBv);
+                        regIndex = GetPreferencedRegIndex(newLifetime, regsBv);
                     }
                     else
                     {
@@ -2550,7 +2550,7 @@ LinearScan::FindReg(Lifetime *newLifetime, IR::RegOpnd *regOpnd, bool force)
             }
             else
             {
-                regIndex = GetPreferrencedRegIndex(newLifetime, regsBv);
+                regIndex = GetPreferencedRegIndex(newLifetime, regsBv);
             }
         }
         else
@@ -2603,7 +2603,7 @@ LinearScan::FindReg(Lifetime *newLifetime, IR::RegOpnd *regOpnd, bool force)
         if (tryCallerSavedRegs)
         {
             Assert(newLifetime);
-            regIndex = GetPreferrencedRegIndex(newLifetime, callerSavedAvailableBv);
+            regIndex = GetPreferencedRegIndex(newLifetime, callerSavedAvailableBv);
             if (BVInvalidIndex == regIndex)
             {
                 tryCallerSavedRegs = false;
@@ -2640,7 +2640,7 @@ LinearScan::FindReg(Lifetime *newLifetime, IR::RegOpnd *regOpnd, bool force)
 }
 
 BVIndex
-LinearScan::GetPreferrencedRegIndex(Lifetime *lifetime, BitVector freeRegs)
+LinearScan::GetPreferencedRegIndex(Lifetime *lifetime, BitVector freeRegs)
 {
     BitVector freePreferencedRegs = freeRegs;
 

lib/Backend/LinearScan.h

@@ -129,7 +129,7 @@ private:
     void                ProcessEHRegionBoundary(IR::Instr * instr);
     void                AllocateStackSpace(Lifetime *spilledRange);
     RegNum              FindReg(Lifetime *newLifetime, IR::RegOpnd *regOpnd, bool force = false);
-    BVIndex             GetPreferrencedRegIndex(Lifetime *lifetime, BitVector freeRegs);
+    BVIndex             GetPreferencedRegIndex(Lifetime *lifetime, BitVector freeRegs);
     void                AddToActive(Lifetime *liveRange);
     void                InsertStores(Lifetime *lifetime, RegNum reg, IR::Instr *insertionInstr);
     void                InsertStore(IR::Instr *instr, StackSym *sym, RegNum reg);

lib/Backend/Lower.cpp

@@ -9461,7 +9461,7 @@ Lowerer::LowerStElemC(IR::Instr * stElem)
             }
             else
             {
-                //Its a missing value store and data flow proves that src1 is always missing value. Array cannot be a int array at the first place
+                //Its a missing value store and data flow proves that src1 is always missing value. Array cannot be an int array at the first place
                 //if this code was ever hit. Just bailout, this code path would be updated with the profile information next time around.
                 InsertBranch(Js::OpCode::Br, labelBailOut, stElem);
 #if DBG
@@ -14906,7 +14906,7 @@ Lowerer::GenerateFastStringLdElem(IR::Instr * ldElem, IR::LabelInstr * labelHelp
     // Load the string buffer and make sure it is not null
     //  MOV bufferOpnd, [baseOpnd + offset(m_pszValue)]
     //  TEST bufferOpnd, bufferOpnd
-    //  JEQ $lableHelper
+    //  JEQ $labelHelper
     indirOpnd = IR::IndirOpnd::New(baseOpnd, offsetof(Js::JavascriptString, m_pszValue), TyMachPtr, this->m_func);
 
     InsertMove(bufferOpnd, indirOpnd, ldElem);
@@ -21218,7 +21218,7 @@ Lowerer::LowerNewScopeSlots(IR::Instr * instr, bool doStackSlots)
     }
     else
     {
-        // Just generate all the assignment in loop of loopUnroolCount and the rest as straight line code
+        // Just generate all the assignment in loop of loopUnrollCount and the rest as straight line code
         //
         //      lea currOpnd, [dst + sizeof(Var) * (loopAssignCount + Js::ScopeSlots::FirstSlotIndex - loopUnrollCount)];
         //      mov [currOpnd + loopUnrollCount + leftOverAssignCount - 1] , undefinedOpnd

lib/Backend/LowerMDShared.cpp

@@ -2926,7 +2926,7 @@ IR::Instr * LowererMD::GenerateConvBool(IR::Instr *instr)
 /// LowererMD::GenerateFastAdd
 ///
 /// NOTE: We assume that only the sum of two Int31's will have 0x2 set. This
-/// is only true until we have an var type with tag == 0x2.
+/// is only true until we have a var type with tag == 0x2.
 ///
 ///----------------------------------------------------------------------------
 bool
@@ -5791,7 +5791,7 @@ LowererMD::GenerateNumberAllocation(IR::RegOpnd * opndDst, IR::Instr * instrInse
     // PUSH allocator
     this->LoadHelperArgument(instrInsert, m_lowerer->LoadScriptContextValueOpnd(instrInsert,  ScriptContextValue::ScriptContextNumberAllocator));
 
-    // dst = Call AllocUninitalizedNumber
+    // dst = Call AllocUninitializedNumber
     IR::Instr * instrCall = IR::Instr::New(Js::OpCode::CALL, opndDst,
         IR::HelperCallOpnd::New(IR::HelperAllocUninitializedNumber, this->m_func), this->m_func);
     instrInsert->InsertBefore(instrCall);
@@ -8066,7 +8066,7 @@ bool
 LowererMD::GenerateLdThisCheck(IR::Instr * instr)
 {
     //
-    // If not an recyclable object, jump to $helper
+    // If not a recyclable object, jump to $helper
     // MOV dst, src1                                      -- return the object itself
     // JMP $fallthrough
     // $helper:

lib/Backend/LowerMDSharedSimd128.cpp

@@ -318,7 +318,7 @@ IR::Instr* LowererMD::Simd128LowerConstructor(IR::Instr *instr)
             // b-namost: better way to implement this on SSE2? Using MOVD directly zeroes upper bits.
             IR::RegOpnd *temp = IR::RegOpnd::New(TyFloat32, m_func);
 
-            // src's might have been constant prop'ed. Enregister them if so.
+            // src's might have been constant prop'd. Enregister them if so.
             src4 = EnregisterIntConst(instr, src4);
             src3 = EnregisterIntConst(instr, src3);
             src2 = EnregisterIntConst(instr, src2);

lib/Backend/NativeCodeGenerator.cpp

@@ -1159,7 +1159,7 @@ NativeCodeGenerator::CheckCodeGen(Js::ScriptFunction * function)
         // Job was not yet processed
         // originalEntryPoint is the last known good entry point for the function body. Here we verify that
         // it either corresponds with this codegen episode (identified by function->entryPointIndex) of the function body
-        // or one that was scheduled after. In the latter case orginalEntryPoint will get updated if and when
+        // or one that was scheduled after. In the latter case originalEntryPoint will get updated if and when
         // that last episode completes successfully.
         Assert(functionBody->GetDefaultEntryPointInfo() == function->GetEntryPointInfo() &&
             (
@@ -1481,7 +1481,7 @@ NativeCodeGenerator::UpdateQueueForDebugMode()
 
     // If we're going to debug mode, drain the job processors queue of
     // all jobs belonging this native code generator
-    // JobProcesed will be called for existing jobs, and in debug mode
+    // JobProcessed will be called for existing jobs, and in debug mode
     // that method will simply add them back to the NativeCodeGen's queue
     Processor()->RemoveManager(this);
 
@@ -2198,7 +2198,7 @@ NativeCodeGenerator::GatherCodeGenData(
             //Try and see if this polymorphic call
             Js::FunctionBody* inlineeFunctionBodyArray[Js::DynamicProfileInfo::maxPolymorphicInliningSize] = {0};
             bool canInlineArray[Js::DynamicProfileInfo::maxPolymorphicInliningSize] = { 0 };
-            uint polyInlineeCount = inliningDecider.InlinePolymorhicCallSite(functionBody, profiledCallSiteId, inlineeFunctionBodyArray,
+            uint polyInlineeCount = inliningDecider.InlinePolymorphicCallSite(functionBody, profiledCallSiteId, inlineeFunctionBodyArray,
                 Js::DynamicProfileInfo::maxPolymorphicInliningSize, canInlineArray);
 
             //We should be able to inline at least two functions here.
@@ -2968,7 +2968,7 @@ bool NativeCodeGenerator::TryAggressiveInlining(Js::FunctionBody *const topFunct
 
     if (!inlineeFunctionBody->GetProfiledCallSiteCount())
     {
-        // Nothing to inline. See this as fully inlineable function.
+        // Nothing to inline. See this as fully inlinable function.
         return true;
     }
 
@@ -3101,7 +3101,7 @@ bool NativeCodeGenerator::TryAggressiveInlining(Js::FunctionBody *const topFunct
                 //Try and see if this polymorphic call
                 Js::FunctionBody* inlineeFunctionBodyArray[Js::DynamicProfileInfo::maxPolymorphicInliningSize] = { 0 };
                 bool canInlineArray[Js::DynamicProfileInfo::maxPolymorphicInliningSize] = { 0 };
-                uint polyInlineeCount = inliningDecider.InlinePolymorhicCallSite(inlineeFunctionBody, profiledCallSiteId, inlineeFunctionBodyArray,
+                uint polyInlineeCount = inliningDecider.InlinePolymorphicCallSite(inlineeFunctionBody, profiledCallSiteId, inlineeFunctionBodyArray,
                     Js::DynamicProfileInfo::maxPolymorphicInliningSize, canInlineArray);
 
                 //We should be able to inline everything here.

lib/Backend/Opnd.inl

@@ -165,7 +165,7 @@ Opnd::IsIntConstOpnd() const
 ///
 /// Opnd::AsIntConstOpnd
 ///
-///     Use this opnd as a IntConstOpnd.
+///     Use this opnd as an IntConstOpnd.
 ///
 ///----------------------------------------------------------------------------
 
@@ -263,7 +263,7 @@ Opnd::IsAddrOpnd() const
 ///
 /// Opnd::AsAddrOpnd
 ///
-///     Use this opnd as a AddrOpnd.
+///     Use this opnd as an AddrOpnd.
 ///
 ///----------------------------------------------------------------------------
 
@@ -291,7 +291,7 @@ Opnd::IsIndirOpnd() const
 ///
 /// Opnd::AsIndirOpnd
 ///
-///     Use this opnd as a IndirOpnd.
+///     Use this opnd as an IndirOpnd.
 ///
 ///----------------------------------------------------------------------------
 

lib/Backend/SCCLiveness.cpp

@@ -546,7 +546,7 @@ SCCLiveness::ProcessRegDef(IR::RegOpnd *regDef, IR::Instr *instr)
         }
     }
 
-    // Arg slot sym can be in an RegOpnd for param passed via registers
+    // Arg slot sym can be in a RegOpnd for param passed via registers
     // Skip creating a lifetime for those.
     if (stackSym->IsArgSlotSym())
     {

lib/Backend/SwitchIRBuilder.cpp

@@ -735,7 +735,7 @@ SwitchIRBuilder::BuildBailOnNotInteger()
 ////////////////////////////////////////////////////////////////////////////////////////////
 ///
 ///SwitchIRBuilder::BuildBailOnNotString
-///     Creates the necessary bailout for a switch case that expected an string expression
+///     Creates the necessary bailout for a switch case that expected a string expression
 ///     but was not.
 ///
 ////////////////////////////////////////////////////////////////////////////////////////////

lib/Backend/SwitchIRBuilder.h

@@ -74,7 +74,7 @@ private:
     bool                            m_isAsmJs;
     bool                            m_switchOptBuildBail; //bool refers to whether the bail out has to be generated or not
     bool                            m_switchIntDynProfile; // bool refers to whether dynamic profile info says that the switch expression is an integer or not
-    bool                            m_switchStrDynProfile; // bool refers to whether dynamic profile info says that the switch expression is an string or not
+    bool                            m_switchStrDynProfile; // bool refers to whether dynamic profile info says that the switch expression is a string or not
     BVSparse<JitArenaAllocator> *   m_intConstSwitchCases;
     StrSwitchCaseList *             m_strConstSwitchCases;
 

lib/Backend/Sym.h

@@ -187,7 +187,7 @@ public:
     uint8           m_isNotInt:1;
     uint8           m_isSafeThis : 1;
     uint8           m_isConst : 1;              // single def and it is a constant
-    uint8           m_isIntConst : 1;           // a constant and it's value is a Int32
+    uint8           m_isIntConst : 1;           // a constant and it's value is an Int32
     uint8           m_isTaggableIntConst : 1;   // a constant and it's value is taggable (Int31 in 32-bit, Int32 in x64)
     uint8           m_isEncodedConstant : 1;    // the constant has
     uint8           m_isFltConst: 1;

lib/Backend/TempTracker.cpp

@@ -24,7 +24,7 @@
  * and on definition of the symbol, if the all the use allow temp object (not in nonTempSyms
  * bitvector) then it is mark them able.
  *
- * However, the complication comes when the stack object is transfered to another symbol
+ * However, the complication comes when the stack object is transferred to another symbol
  * and we are in a loop.  We need to make sure that the stack object isn't still referred
  * by another symbol when we allocate the number/object in the next iteration
  *
@@ -101,7 +101,7 @@ TempTrackerBase::AddTransferDependencies(BVSparse<JitArenaAllocator> * bv, SymID
 {
     bv->Set(dstSymID);
 
-    // Add the indirect transfers (always from tempTransferDepencies)
+    // Add the indirect transfers (always from tempTransferDependencies)
     BVSparse<JitArenaAllocator> *dstBVSparse = this->tempTransferDependencies->GetAndClear(dstSymID);
     if (dstBVSparse != nullptr)
     {
@@ -188,7 +188,7 @@ TempTrackerBase::Dump(wchar_t const * traceName)
 {
     Output::Print(L"%s:        Non temp syms:", traceName);
     this->nonTempSyms.Dump();
-    Output::Print(L"%s: Temp transfered syms:", traceName);
+    Output::Print(L"%s: Temp transferred syms:", traceName);
     this->tempTransferredSyms.Dump();
     if (this->tempTransferDependencies != nullptr)
     {
@@ -289,7 +289,7 @@ TempTracker<T>::MarkTemp(StackSym * sym, BackwardPass * backwardPass)
 
     IR::Instr * instr = backwardPass->currentInstr;
     BOOLEAN nonTemp = this->nonTempSyms.TestAndClear(sym->m_id);
-    BOOLEAN isTempTransfered;
+    BOOLEAN isTempTransferred;
     BVSparse<JitArenaAllocator> * bvTempTransferDependencies = nullptr;
 
     bool const isTransferOperation =
@@ -302,19 +302,19 @@ TempTracker<T>::MarkTemp(StackSym * sym, BackwardPass * backwardPass)
         // Since we don't iterate "while (!changed)" in loops, we don't have complete accurate dataflow
         // for loop carried dependencies. So don't clear the dependency transfer info.  WOOB:1121525
 
-        // Check if this dst is transfered (assigned) to another symbol
+        // Check if this dst is transferred (assigned) to another symbol
         if (isTransferOperation)
         {
-            isTempTransfered = this->tempTransferredSyms.Test(sym->m_id);
+            isTempTransferred = this->tempTransferredSyms.Test(sym->m_id);
         }
         else
         {
-            isTempTransfered = this->tempTransferredSyms.TestAndClear(sym->m_id);
+            isTempTransferred = this->tempTransferredSyms.TestAndClear(sym->m_id);
         }
 
         // We only need to look at the dependencies if we are in a loop because of the back edge
         // Also we don't need to if we are in pre pass
-        if (isTempTransfered)
+        if (isTempTransferred)
         {
             if (!backwardPass->IsPrePass())
             {
@@ -343,7 +343,7 @@ TempTracker<T>::MarkTemp(StackSym * sym, BackwardPass * backwardPass)
     }
     else
     {
-        isTempTransfered = this->tempTransferredSyms.TestAndClear(sym->m_id);
+        isTempTransferred = this->tempTransferredSyms.TestAndClear(sym->m_id);
     }
 
     // Reset the dst is temp bit (we set it optimistically on the loop pre pass)
@@ -388,9 +388,9 @@ TempTracker<T>::MarkTemp(StackSym * sym, BackwardPass * backwardPass)
     {
         dstIsTemp = true;
 
-        if (isTempTransfered)
+        if (isTempTransferred)
         {
-            // Track whether the dst is transfered or not, and allocate separate stack slot for them
+            // Track whether the dst is transferred or not, and allocate separate stack slot for them
             // so that another dst will not overrides the value
             dstIsTempTransferred = true;
 
@@ -399,7 +399,7 @@ TempTracker<T>::MarkTemp(StackSym * sym, BackwardPass * backwardPass)
 
             if (bvTempTransferDependencies != nullptr)
             {
-                // Inside a loop we need to track if any of the reg that we transfered to is still live
+                // Inside a loop we need to track if any of the reg that we transferred to is still live
                 //      s1 = Add
                 //         = s2
                 //      s2 = s1
@@ -432,7 +432,7 @@ TempTracker<T>::MarkTemp(StackSym * sym, BackwardPass * backwardPass)
                     {
                         Output::Print(L"%s: Not temp (s%-03d): ", T::GetTraceName(), sym->m_id);
                         instr->DumpSimple();
-                        Output::Print(L"       Transfered exposed uses: ");
+                        Output::Print(L"       Transferred exposed uses: ");
                         JitArenaAllocator tempAllocator(L"temp", this->GetAllocator()->GetPageAllocator(), Js::Throw::OutOfMemory);
                         bvTempTransferDependencies->AndNew(upwardExposedUses, &tempAllocator)->Dump();
                     }
@@ -509,7 +509,7 @@ NumberTemp::IsTempUse(IR::Instr * instr, Sym * sym, BackwardPass * backwardPass)
             || !instr->GetDst()->AsIndirOpnd()->GetBaseOpnd()->GetValueType().IsLikelyOptimizedTypedArray())
         {
             // Mark the symbol as non-tempable if the instruction doesn't allow temp sources,
-            // or it is transfered to a non-temp dst
+            // or it is transferred to a non-temp dst
             return false;
         }
     }
@@ -658,7 +658,7 @@ NumberTemp::SetDstIsTemp(bool dstIsTemp, bool dstIsTempTransferred, IR::Instr *
     if (!backwardPass->IsPrePass() && IsTempProducing(instr))
     {
         backwardPass->numMarkTempNumber += dstIsTemp;
-        backwardPass->numMarkTempNumberTransfered += dstIsTempTransferred;
+        backwardPass->numMarkTempNumberTransferred += dstIsTempTransferred;
     }
 #endif
 }
@@ -766,7 +766,7 @@ NumberTemp::PropagateTempPropertyTransferStoreDependencies(SymID usedSymID, Prop
     AddTransferDependencies(usedSymID, dstSymID, this->tempTransferDependencies);
 
     Js::PropertyId storedPropertyId = propertySym->m_propertyId;
-    // The symbol this properties are transfered to
+    // The symbol this properties are transferred to
     BVSparse<JitArenaAllocator> ** pPropertyTransferDependencies = this->propertyIdsTempTransferDependencies->Get(storedPropertyId);
     BVSparse<JitArenaAllocator> * transferDependencies = nullptr;
     if (pPropertyTransferDependencies == nullptr)
@@ -1046,7 +1046,7 @@ ObjectTemp::IsTempUseOpCodeSym(IR::Instr * instr, Js::OpCode opcode, Sym * sym)
     }
 
     // Mark the symbol as non-tempable if the instruction doesn't allow temp sources,
-    // or it is transfered to a non-temp dst
+    // or it is transferred to a non-temp dst
     return (OpCodeAttr::TempObjectSources(opcode)
         && (!OpCodeAttr::TempObjectTransfer(opcode) || instr->dstIsTempObject));
 }
@@ -1145,7 +1145,7 @@ ObjectTemp::ProcessInstr(IR::Instr * instr)
         case IR::JnHelperMethod::HelperString_Match:
         case IR::JnHelperMethod::HelperString_Replace:
         {
-            // First (non-this) parameter is either an regexp or search string.
+            // First (non-this) parameter is either a regexp or search string.
             // It doesn't escape.
             IR::Instr * instrArgDef;
             instr->FindCallArgumentOpnd(2, &instrArgDef);
@@ -1292,7 +1292,7 @@ ObjectTempVerify::IsTempTransfer(IR::Instr * instr)
         if (!instr->dstIsTempObject && instr->GetDst() && instr->GetDst()->IsRegOpnd()
           && instr->GetDst()->AsRegOpnd()->GetValueType().IsNotObject())
         {
-            // Globopt has proved that dst is not a object, so this is not really an object transfer.
+            // Globopt has proved that dst is not an object, so this is not really an object transfer.
             // This prevents the case where glob opt turned a Conv_Num to Ld_A and expose additional
             // transfer.
             return false;
@@ -1331,7 +1331,7 @@ ObjectTempVerify::ProcessInstr(IR::Instr * instr, BackwardPass * backwardPass)
         case IR::JnHelperMethod::HelperString_Match:
         case IR::JnHelperMethod::HelperString_Replace:
         {
-            // First (non-this) parameter is either an regexp or search string
+            // First (non-this) parameter is either a regexp or search string
             // It doesn't escape
             IR::Instr * instrArgDef;
             instr->FindCallArgumentOpnd(2, &instrArgDef);
@@ -1607,7 +1607,7 @@ ObjectTempVerify::DependencyCheck(IR::Instr * instr, BVSparse<JitArenaAllocator>
 
             if (currentInstr->GetDst() && currentInstr->GetDst()->IsRegOpnd())
             {
-                // Clear the def and mark the src if it is transfered.
+                // Clear the def and mark the src if it is transferred.
 
                 // If the dst sym is a type specialized sym, clear the var sym instead.
                 StackSym * dstSym = currentInstr->GetDst()->AsRegOpnd()->m_sym;

lib/Backend/amd64/LinearScanMD.cpp

@@ -111,7 +111,7 @@ LinearScanMD::LegalizeConstantUse(IR::Instr * instr, IR::Opnd * opnd)
     {
         Assert(this->linearScan->instrUseRegs.IsEmpty());
 
-        // MOV doesn't have a imm8 encoding for 32-bit/64-bit assignment, so if we have a register available,
+        // MOV doesn't have an imm8 encoding for 32-bit/64-bit assignment, so if we have a register available,
         // we should hoist it and generate xor reg, reg and MOV dst, reg
         BitVector regsBv;
         regsBv.Copy(this->linearScan->activeRegs);

lib/Backend/amd64/LowererMDArch.cpp

@@ -483,7 +483,7 @@ LowererMDArch::LowerCallArgs(IR::Instr *callInstr, ushort callFlags, Js::ArgSlot
         cfgInsertLoc = argInstr->GetPrevRealInstr();
 
         // The arg sym isn't assigned a constant directly anymore
-        // TODO: We can just move the instruction down next to the call if it is just an constant assignment
+        // TODO: We can just move the instruction down next to the call if it is just a constant assignment
         // but AMD64 doesn't have the MOV mem,imm64 encoding, and we have no code to detect if the value can fit
         // into imm32 and hoist the src if it is not.
         argLinkSym->m_isConst = false;
@@ -1640,7 +1640,7 @@ LowererMDArch::GeneratePrologueStackProbe(IR::Instr *entryInstr, IntConstType fr
         insertInstr->InsertBefore(instr);
         Security::InsertRandomFunctionPad(insertInstr);
 
-        // This is generated after layout.   Generate the block at the end of the function manually
+        // This is generated after layout. Generate the block at the end of the function manually
         insertInstr = IR::PragmaInstr::New(Js::OpCode::StatementBoundary, Js::Constants::NoStatementIndex, m_func);
 
         this->m_func->m_tailInstr->InsertAfter(insertInstr);
@@ -2604,7 +2604,7 @@ bool LowererMDArch::GenerateFastShiftRight(IR::Instr * instrShift)
         // 32-bit Shifts only uses the bottom 5 bits.
         s2Value &=  0x1F;
 
-        // Unsigned shift by 0 could yield a value not encodable as an tagged int.
+        // Unsigned shift by 0 could yield a value not encodable as a tagged int.
         if (isUnsigned && src2IsIntConst && s2Value == 0)
         {
             return true;
@@ -2742,7 +2742,7 @@ LowererMDArch::FinalLower()
             if (instr->GetSrc2())
             {
                 // CMOV inserted before regalloc have a dummy src1 to simulate the fact that
-                // CMOV is not an definite def of the dst.
+                // CMOV is not a definite def of the dst.
                 instr->SwapOpnds();
                 instr->FreeSrc2();
             }

lib/Backend/arm/LegalizeMD.cpp

@@ -582,7 +582,7 @@ bool LegalizeMD::LegalizeDirectBranch(IR::BranchInstr *branchInstr, uint32 branc
         return false;
     }
 
-    // Convert an conditional branch which can only be +-1MB to unconditional branch which is +-16MB
+    // Convert a conditional branch which can only be +-1MB to unconditional branch which is +-16MB
     // Convert beq Label (where Label is long jump) to something like this
     //          bne Fallback
     //          b Label

lib/Backend/arm/LowerMD.cpp

@@ -1425,7 +1425,7 @@ LowererMD::LowerEntryInstr(IR::EntryInstr * entryInstr)
                 // And if we're probing the stack dynamically, we need an extra reg to do the frame size calculation.
                 //
                 // Note that it's possible that we now no longer need a dynamic stack probe because
-                // m_localStackHeight may be encodeable in Mod12. However, this is a chicken-and-egg
+                // m_localStackHeight may be encodable in Mod12. However, this is a chicken-and-egg
                 // problem, so we're going to stick with saving R4 even though it's possible it
                 // won't get modified.
                 usedRegs.Set(RegEncode[SP_ALLOC_SCRATCH_REG]);
@@ -3509,7 +3509,7 @@ IR::Instr * LowererMD::GenerateConvBool(IR::Instr *instr)
 /// LowererMD::GenerateFastAdd
 ///
 /// NOTE: We assume that only the sum of two Int31's will have 0x2 set. This
-/// is only true until we have an var type with tag == 0x2.
+/// is only true until we have a var type with tag == 0x2.
 ///
 ///----------------------------------------------------------------------------
 
@@ -6086,7 +6086,7 @@ LowererMD::LoadCheckedFloat(
     IR::Instr *instrInsert,
     const bool checkForNullInLoopBody)
 {
-    // Load one floating-point var into an VFP register, inserting checks to see if it's really a float:
+    // Load one floating-point var into a VFP register, inserting checks to see if it's really a float:
     // Rx = ASRS src, 1
     //      BCC $non-int
     // Dx = VMOV Rx
@@ -6466,7 +6466,7 @@ LowererMD::GenerateNumberAllocation(IR::RegOpnd * opndDst, IR::Instr * instrInse
     // arg1 = allocator
     this->LoadHelperArgument(instrInsert, m_lowerer->LoadScriptContextValueOpnd(instrInsert, ScriptContextValue::ScriptContextNumberAllocator));
 
-    // dst = Call AllocUninitalizedNumber
+    // dst = Call AllocUninitializedNumber
     IR::Instr * instrCall = IR::Instr::New(Js::OpCode::Call, opndDst,
         IR::HelperCallOpnd::New(IR::HelperAllocUninitializedNumber, this->m_func), this->m_func);
     instrInsert->InsertBefore(instrCall);

lib/Backend/i386/LowererMDArch.cpp

@@ -3640,7 +3640,7 @@ LowererMDArch::FinalLower()
             if (instr->GetSrc2())
             {
                 // CMOV inserted before regalloc have a dummy src1 to simulate the fact that
-                // CMOV is not an definite def of the dst.
+                // CMOV is not a definite def of the dst.
                 instr->SwapOpnds();
                 instr->FreeSrc2();
             }

lib/Parser/CharClassifier.h

@@ -35,7 +35,7 @@ enum CharTypeFlags : uint
 
 enum CharTypes
 {
-    _C_UNK,    // Unkown grouping
+    _C_UNK,    // Unknown grouping
     _C_ERR,    // illegal character
     _C_NUL,    // NUL character
     _C_LET,    // letter (A-Z,a-z)

lib/Parser/ParseTreeComparer.h

@@ -382,7 +382,7 @@ namespace Js
         }
 
         //
-        // Check if a node has token (node type ownning an implicit token, e.g. "var x" (var declaration)).
+        // Check if a node has token (node type owning an implicit token, e.g. "var x" (var declaration)).
         //
         static bool HasToken(ParseNode* pnode)
         {

lib/Parser/RegexCompileTime.cpp

@@ -515,7 +515,7 @@ namespace UnifiedRegex
                         //
                         // Obviously starting later in the string won't help, so can hard fail if:
                         //  - this pattern must always be matched
-                        //  - not in an negative assertion
+                        //  - not in a negative assertion
                         //  - backtracking could never rewind the input pointer
                         //
                         EMIT(compiler, BOITestInst, isAtLeastOnce && isNotNegated && isPrevWillNotRegress);
@@ -540,7 +540,7 @@ namespace UnifiedRegex
                     //
                     // Can hard fail if
                     //  - this pattern must always be matched
-                    //  - not in an negative assertion
+                    //  - not in a negative assertion
                     //  - backtracking could never advance the input pointer
                     //
                     EMIT(compiler, EOITestInst, isAtLeastOnce && isNotNegated && isPrevWillNotProgress);
@@ -2223,7 +2223,7 @@ namespace UnifiedRegex
             // Recalculate firstSet. Since it can only get smaller, and alternative could not have had an exact
             // first set, this recalculation does not make any decisions already made based on the current firstSet
             // unsound.
-            // NOTE: Is it worth recalculating the WillNotProgess/WillNotRegress bools?
+            // NOTE: Is it worth recalculating the WillNotProgress/WillNotRegress bools?
             firstSet = Anew(compiler.ctAllocator, UnicodeCharSet);
             for (AltNode* curr = this; curr != 0; curr = curr->tail)
                 firstSet->UnionInPlace(compiler.ctAllocator, *curr->head->firstSet);

lib/Parser/RegexCompileTime.h

@@ -550,7 +550,7 @@ namespace UnifiedRegex
         enum CompilationScheme
         {
             BeginEnd,     // Protect assertion with begin/end instructions
-            Succ,         // Assertion will always succeeed, without binding groups
+            Succ,         // Assertion will always succeed, without binding groups
             Fail          // Assertion will always fail
         };
 
@@ -591,7 +591,7 @@ namespace UnifiedRegex
         static const CharCount initInstBufSize = 128;
 
         Js::ScriptContext* scriptContext;
-        // Arena for nodes and items needed only during compliation
+        // Arena for nodes and items needed only during compilation
         ArenaAllocator* ctAllocator;
         // Arena for literals, sets and items needed during runtime
         ArenaAllocator* rtAllocator;

lib/Parser/RegexParser.cpp

@@ -2042,8 +2042,8 @@ namespace UnifiedRegex
 
         CharSet<codepoint_t> codePointSet;
 
-        MatchSetNode defferedSetNode(false, false);
-        MatchCharNode defferedCharNode(0);
+        MatchSetNode deferredSetNode(false, false);
+        MatchCharNode deferredCharNode(0);
 
         bool isNegation = false;
 
@@ -2081,7 +2081,7 @@ namespace UnifiedRegex
             }
             else if (nextChar == '\\')
             {
-                Node* returnedNode = ClassEscapePass1(&defferedCharNode, &defferedSetNode, previousWasASurrogate);
+                Node* returnedNode = ClassEscapePass1(&deferredCharNode, &deferredSetNode, previousWasASurrogate);
 
                 if (returnedNode->tag == Node::MatchSet)
                 {
@@ -2092,13 +2092,13 @@ namespace UnifiedRegex
                         codePointSet.Set(ctAllocator, '-');
                     }
                     pendingRangeStart = INVALID_CODEPOINT;
-                    codePointSet.UnionInPlace(ctAllocator, defferedSetNode.set);
+                    codePointSet.UnionInPlace(ctAllocator, deferredSetNode.set);
                 }
                 else
                 {
                     // Just a character
                     codePointToSet = pendingCodePoint;
-                    pendingCodePoint = defferedCharNode.cs[0];
+                    pendingCodePoint = deferredCharNode.cs[0];
                 }
             }
             else if (nextChar == '-')

lib/Parser/RegexParser.h

@@ -62,7 +62,7 @@ namespace UnifiedRegex
         static const CharCount initLitbufSize = 16;
 
         Js::ScriptContext* scriptContext;
-        // Arena for nodes and items needed only during compliation
+        // Arena for nodes and items needed only during compilation
         ArenaAllocator* ctAllocator;
         // Standard characters using raw encoding character representation (eg char for utf-8)
         StandardChars<EncodedChar>* standardEncodedChars;
@@ -224,7 +224,7 @@ namespace UnifiedRegex
         //  - inputLim may point to the terminating null in above or before it
         //     - if the later, input is known to be syntactically well-formed so that the parser
         //       will find the natural end of the regex literal before passing inputLim
-        //  - input may conatin nulls before the inputLim
+        //  - input may contain nulls before the inputLim
 
         Node* ParseLiteral
             ( const EncodedChar* input          // non null, null terminated (may contain embedded nulls)

lib/Parser/hash.h

@@ -242,7 +242,7 @@ public:
             }
 
             if (ref->id == maxScopeId
-                // If we match the different maxScopeId, then this match is sufficent if it is a decl.
+                // If we match the different maxScopeId, then this match is sufficient if it is a decl.
                 // This is because the parameter scope decl would have been created before this point.
                 && ref->sym != nullptr)
             {

lib/Parser/parse.cpp

@@ -2117,7 +2117,7 @@ ParseNodePtr Parser::ParseTerm(BOOL fAllowCall,
 
         m_pscan->Scan();
 
-        // We search an Async expression (a function declaration or a async lambda expression)
+        // We search for an Async expression (a function declaration or an async lambda expression)
         if (pid == wellKnownPropertyPids.async &&
             !m_pscan->FHadNewLine() &&
             m_scriptContext->GetConfig()->IsES7AsyncAndAwaitEnabled())
@@ -2681,7 +2681,7 @@ ParseNodePtr Parser::ParsePostfixOperators(
                            str,
                            pnode->sxBin.pnode2->sxPid.pid->Cch(),
                            &uintValue) &&
-                       !Js::TaggedInt::IsOverflow(uintValue)) // the optimization is not very useful if the number can't be represented as an TaggedInt
+                       !Js::TaggedInt::IsOverflow(uintValue)) // the optimization is not very useful if the number can't be represented as a TaggedInt
                     {
                         // No need to verify that uintValue != JavascriptArray::InvalidIndex since all nonnegative TaggedInts are valid indexes
                         auto intNode = CreateIntNodeWithScanner(uintValue); // implicit conversion from uint32 to long
@@ -2963,7 +2963,7 @@ ParseNodePtr Parser::ParseArrayLiteral()
 }
 
 /***************************************************************************
-Create a ArrayLiteral node
+Create an ArrayLiteral node
 Parse a list of array elements. [ a, b, , c, ]
 ***************************************************************************/
 template<bool buildAST>
@@ -4648,7 +4648,7 @@ void Parser::ParseTopLevelDeferredFunc(ParseNodePtr pnodeFnc, ParseNodePtr pnode
     }
     else
     {
-        ParseStmtList<false>(nullptr, nullptr, SM_DeferedParse, true /* isSourceElementList */);
+        ParseStmtList<false>(nullptr, nullptr, SM_DeferredParse, true /* isSourceElementList */);
     }
 
     pnodeFnc->ichLim = m_pscan->IchLimTok();
@@ -5031,7 +5031,7 @@ void Parser::ParseNestedDeferredFunc(ParseNodePtr pnodeFnc, bool fLambda, bool *
             m_ppnodeVar = &m_currentNodeDeferredFunc->sxFnc.pnodeVars;
         }
 
-        ParseStmtList<false>(nullptr, nullptr, SM_DeferedParse, true /* isSourceElementList */, detectStrictModeOn);
+        ParseStmtList<false>(nullptr, nullptr, SM_DeferredParse, true /* isSourceElementList */, detectStrictModeOn);
 
         ChkCurTokNoScan(tkRCurly, ERRnoRcurly);
     }
@@ -7266,7 +7266,7 @@ ParseNodePtr Parser::ParseExpr(int oplMin,
         }
         else
         {
-            // Disallow spread after a Ellipsis token. This prevents chaining, and ensures spread is the top level expression.
+            // Disallow spread after an Ellipsis token. This prevents chaining, and ensures spread is the top level expression.
             pnodeT = ParseExpr<buildAST>(opl, &fCanAssign, TRUE, nop != knopEllipsis && fAllowEllipsis, nullptr /*hint*/, nullptr /*hintLength*/, nullptr /*hintOffset*/, &operandToken, true);
         }
 
@@ -8921,13 +8921,13 @@ LEndSwitch:
         {
             if (pnode)
             {
-                pnode->grfpn |= PNodeFlags::fpnExplicitSimicolon;
+                pnode->grfpn |= PNodeFlags::fpnExplicitSemicolon;
             }
             m_pscan->Scan();
         }
         else if (pnode)
         {
-            pnode->grfpn |= PNodeFlags::fpnAutomaticSimicolon;
+            pnode->grfpn |= PNodeFlags::fpnAutomaticSemicolon;
         }
 
         break;
@@ -9357,11 +9357,11 @@ LNeedTerminator:
         {
         case tkSColon:
             m_pscan->Scan();
-            if (pnode!= nullptr) pnode->grfpn |= PNodeFlags::fpnExplicitSimicolon;
+            if (pnode!= nullptr) pnode->grfpn |= PNodeFlags::fpnExplicitSemicolon;
             break;
         case tkEOF:
         case tkRCurly:
-            if (pnode!= nullptr) pnode->grfpn |= PNodeFlags::fpnAutomaticSimicolon;
+            if (pnode!= nullptr) pnode->grfpn |= PNodeFlags::fpnAutomaticSemicolon;
             break;
         default:
             if (!m_pscan->FHadNewLine())
@@ -9370,7 +9370,7 @@ LNeedTerminator:
             }
             else
             {
-                if (pnode!= nullptr) pnode->grfpn |= PNodeFlags::fpnAutomaticSimicolon;
+                if (pnode!= nullptr) pnode->grfpn |= PNodeFlags::fpnAutomaticSemicolon;
             }
             break;
         }
@@ -10375,7 +10375,7 @@ HRESULT Parser::ParseFunctionInBackground(ParseNodePtr pnodeFnc, ParseContext *p
         // Process a sequence of statements/declarations
         if (topLevelDeferred)
         {
-            ParseStmtList<false>(nullptr, nullptr, SM_DeferedParse, true);
+            ParseStmtList<false>(nullptr, nullptr, SM_DeferredParse, true);
         }
         else
         {

lib/Parser/parse.h

@@ -160,11 +160,11 @@ public:
 
     HRESULT ValidateSyntax(LPCUTF8 pszSrc, size_t encodedCharCount, bool isGenerator, bool isAsync, CompileScriptException *pse, void (Parser::*validateFunction)());
 
-    // Should be called when the UTF-8 source was produced from UTF-16. This is really CESU-8 source in that it encodes surragate pairs
-    // as 2 three byte sequences instead of 4 bytes as required UTF-8. It also is is loss-less converison of invalid UTF-16 sequences.
-    // This is important in Javascript because Javascript engines are required not report invalid UTF-16 sequences and to consider
-    // the UTF-16 characters pre-canonacalized. Converting this UTF-16 with invalid sequences to valid UTF-8 and back would cause
-    // all invalid UTF-16 seqences to be replace by one or more Unicode replacement characters (0xFFFD), losing the original
+    // Should be called when the UTF-8 source was produced from UTF-16. This is really CESU-8 source in that it encodes surrogate pairs
+    // as 2 three byte sequences instead of 4 bytes as required by UTF-8. It also is a lossless conversion of invalid UTF-16 sequences.
+    // This is important in Javascript because Javascript engines are required not to report invalid UTF-16 sequences and to consider
+    // the UTF-16 characters pre-canonicalization. Converting this UTF-16 with invalid sequences to valid UTF-8 and back would cause
+    // all invalid UTF-16 sequences to be replaced by one or more Unicode replacement characters (0xFFFD), losing the original
     // invalid sequences.
     HRESULT ParseCesu8Source(__out ParseNodePtr* parseTree, LPCUTF8 pSrc, size_t length, ULONG grfsrc, CompileScriptException *pse,
         Js::LocalFunctionId * nextFunctionId, SourceContextInfo * sourceContextInfo);
@@ -373,7 +373,7 @@ private:
     ParseNodePtr m_currentNodeNonLambdaDeferredFunc; // current function or NULL
     ParseNodePtr m_currentNodeFunc; // current function or NULL
     ParseNodePtr m_currentNodeDeferredFunc; // current function or NULL
-    ParseNodePtr m_currentNodeProg; // current programm
+    ParseNodePtr m_currentNodeProg; // current program
     DeferredFunctionStub *m_currDeferredStub;
     long * m_pCurrentAstSize;
     ParseNodePtr * m_ppnodeScope;  // function list tail
@@ -627,7 +627,7 @@ private:
         SM_NotUsed,         // StrictMode environment is don't care
         SM_OnGlobalCode,    // The current environment is a global code
         SM_OnFunctionCode,  // The current environment is a function code
-        SM_DeferedParse     // StrictMode used in defered parse cases
+        SM_DeferredParse    // StrictMode used in deferred parse cases
     };
 
     template<bool buildAST> ParseNodePtr ParseArrayLiteral();

lib/Parser/perrors.h

@@ -69,7 +69,7 @@ LSC_ERROR_MSG( 1062, ERRnoDArrow      , "Expected '=>'")
 LSC_ERROR_MSG( 1063, ERRInvalidCodePoint      , "Invalid codepoint value in the escape sequence.")
 LSC_ERROR_MSG( 1064, ERRMissingCurlyBrace      , "Closing curly brace ('}') expected.")
 LSC_ERROR_MSG( 1065, ERRRestLastArg, "The rest parameter must be the last parameter in a formals list.")
-LSC_ERROR_MSG( 1066, ERRRestWithDefault, "The rest parameter cannot have a default intializer.")
+LSC_ERROR_MSG( 1066, ERRRestWithDefault, "The rest parameter cannot have a default initializer.")
 LSC_ERROR_MSG( 1067, ERRUnexpectedEllipsis, "Unexpected ... operator")
 
 LSC_ERROR_MSG( 1068, ERRDestructInit, "Destructuring declarations must have an initializer")

lib/Parser/pnodediff.h

@@ -33,18 +33,18 @@ enum EditKind
 //      EUGENE W. MYERS: An O(ND) Difference Algorithm and Its Variations
 //
 // The idea is that LCS is a dual problem of shortest path in an edit graph. The edit graph is a grid of lengthA
-// columns and lengthB rows. A path starts from (0,0) and moves toward (lenghA, lengthB).
+// columns and lengthB rows. A path starts from (0,0) and moves toward (lengthA, lengthB).
 //  - A horizontal move (i,j) -> (i+1,j) represents deleting A[i].
 //  - A vertical move (i,j) -> (i,j+1) represents inserting B[j].
 //  - A diagonal move (i,j) -> (i+1,j+1) represents a match, A[i] == B[j].
-// Each diagonal move represents a match. We want more diagnonal moves. Let diagonal move cost 0, horizontal or
-// vertical move each costs 1. The basic algorithm is a greedy algorthm to find a shortest path from (0,0) to
+// Each diagonal move represents a match. We want more diagonal moves. Let diagonal move cost 0, horizontal or
+// vertical move each costs 1. The basic algorithm is a greedy algorithm to find a shortest path from (0,0) to
 // (lengthA, lengthB).
 //
 // Terms:
-//  diagonal k: The diagnonal where x-y==k.
+//  diagonal k: The diagonal where x-y==k.
 //  d-path: A path starting from (0,0) with d number of horizontal or vertical moves. Or, its length is d (note
-//          that each horizontal/vertical move costs 1, diagnonal move costs 0).
+//          that each horizontal/vertical move costs 1, diagonal move costs 0).
 //
 //          0-path can only move along and end on diagonal 0.
 //          1-path can only end on diagonal -1 or 1.
@@ -547,14 +547,14 @@ private:
         //
         // 1) A label may be marked "tied to parent". Let x, y have both label l and l is "tied to parent".
         //    Then (x,y) can be in M only if (parent(x), parent(y)) in M.
-        //    Thus we require labels of children tied to a parent to be preceeded by all their possible parent labels.
+        //    Thus we require labels of children tied to a parent to be preceded by all their possible parent labels.
         //
         // 2) Rather than defining function equal in terms of constants f and t, which are hard to get right,
-        //    we try to match multiple times with different threashold for node distance.
+        //    we try to match multiple times with different thresholds for node distance.
         //    The comparer defines the distance [0..1] between two nodes and it can do so by analyzing
         //    the node structure and value. The comparer can tune the distance specifically for each node kind.
-        //    We first try to match nodes of the same labels to the exactly matching or almost matching counterpars.
-        //    The we keep increasing the threashold and keep adding matches.
+        //    We first try to match nodes of the same labels to the exactly matching or almost matching counterparts.
+        //    Then we keep increasing the threshold and keep adding matches.
         for (int label = 0; label < labelCount; label++)
         {
             if (nodes1[label] && nodes2[label])
@@ -610,7 +610,7 @@ private:
                 if (tiedToAncestor > 0)
                 {
                     // TODO: For nodes tied to their parents,
-                    // consider avoding matching them to all other nodes of the same label.
+                    // consider avoiding matching them to all other nodes of the same label.
                     // Rather we should only match them with their siblings that share the same parent.
 
                     PNode ancestor1 = comparer.GetAncestor(node1, tiedToAncestor);

lib/Parser/pnodevisit.h

@@ -4,7 +4,7 @@
 //-------------------------------------------------------------------------------------------------------
 #pragma once
 
-// Minimum amout of memory on the stack required by a vistor call.
+// Minimum amount of memory on the stack required by a visitor call.
 // Use this value to control when to stop the visitor recursion before a SOE occurs.
 #define PNODEVISIRORSIZE 256
 

lib/Parser/pnodewalk.h

@@ -108,7 +108,7 @@ private:
         return result;
     }
 
-    ResultType WalkTiernary(ParseNode *pnode, Context context)
+    ResultType WalkTernary(ParseNode *pnode, Context context)
     {
         ResultType result = WalkFirstChild(pnode->sxTri.pnode1, context);
         if (ContinueWalk(result))
@@ -421,10 +421,10 @@ private:
         case knopIndex:
             return WalkCall(pnode, context);
 
-        // Tierinary operator
+        // Ternary operator
         //PTNODE(knopQmark      , "?"            ,None    ,Tri  ,fnopBin)
         case knopQmark:
-            return WalkTiernary(pnode, context);
+            return WalkTernary(pnode, context);
 
         // General nodes.
         //PTNODE(knopList       , "<list>"    ,None    ,Bin  ,fnopNone)

lib/Parser/ptree.h

@@ -42,19 +42,19 @@ enum PNodeFlags : ushort
     fpnArguments                             = 0x0004,
     fpnHidden                                = 0x0008,
 
-    // Statment nodes.
-    fpnExplicitSimicolon                     = 0x0010, // statment terminated by an explicit semicolon
-    fpnAutomaticSimicolon                    = 0x0020, // statment terminated by an automatic semicolon
-    fpnMissingSimicolon                      = 0x0040, // statment missing terminating semicolon, and is not applicable for automatic semicolon insersion
-    fpnDclList                               = 0x0080, // statment is a declaration list
+    // Statement nodes.
+    fpnExplicitSemicolon                     = 0x0010, // statement terminated by an explicit semicolon
+    fpnAutomaticSemicolon                    = 0x0020, // statement terminated by an automatic semicolon
+    fpnMissingSemicolon                      = 0x0040, // statement missing terminating semicolon, and is not applicable for automatic semicolon insertion
+    fpnDclList                               = 0x0080, // statement is a declaration list
     fpnSyntheticNode                         = 0x0100, // node is added by the parser or does it represent user code
     fpnIndexOperator                         = 0x0200, // dot operator is an optimization of an index operator
     fpnJumbStatement                         = 0x0400, // break or continue that was removed by error recovery
 
     // Unary/Binary nodes
-    fpnCanFlattenConcatExpr                  = 0x0800, // the result of the binary operation can particpate in concat N
+    fpnCanFlattenConcatExpr                  = 0x0800, // the result of the binary operation can participate in concat N
 
-    // Potentially overlapping transitor flags
+    // Potentially overlapping traversal flags
     // These flags are set and cleared during a single node traversal and their values can be used in other node traversals.
     fpnMemberReference                       = 0x1000, // The node is a member reference symbol
     fpnCapturesSyms                          = 0x2000, // The node is a statement (or contains a sub-statement)
@@ -153,9 +153,9 @@ struct PnArrLit : PnUni
 {
     uint count;
     uint spreadCount;
-    BYTE arrayOfTaggedInts:1;     // indicates that array initialzer nodes are all tagged ints
-    BYTE arrayOfInts:1;           // indicates that array initialzer nodes are all ints
-    BYTE arrayOfNumbers:1;        // indicates that array initialzer nodes are all numbers
+    BYTE arrayOfTaggedInts:1;     // indicates that array initializer nodes are all tagged ints
+    BYTE arrayOfInts:1;           // indicates that array initializer nodes are all ints
+    BYTE arrayOfNumbers:1;        // indicates that array initializer nodes are all numbers
     BYTE hasMissingValues:1;
 };
 
@@ -177,7 +177,7 @@ enum FncFlags
     kFunctionCallsEval                          = 1 << 2, // function uses eval
     kFunctionUsesArguments                      = 1 << 3, // function uses arguments
     kFunctionHasHeapArguments                   = 1 << 4, // function's "arguments" escape the scope
-    kFunctionHasReferencableBuiltInArguments    = 1 << 5, // the built-in 'arguments' object is referenceable in the function
+    kFunctionHasReferenceableBuiltInArguments   = 1 << 5, // the built-in 'arguments' object is referenceable in the function
     kFunctionIsAccessor                         = 1 << 6, // function is a property getter or setter
     kFunctionHasNonThisStmt                     = 1 << 7,
     kFunctionStrictMode                         = 1 << 8,
@@ -279,10 +279,10 @@ public:
     void SetHasDestructuringPattern(bool set = true) { SetFlags(kFunctionHasDestructuringPattern, set); }
     void SetHasHeapArguments(bool set = true) { SetFlags(kFunctionHasHeapArguments, set); }
     void SetHasNonThisStmt(bool set = true) { SetFlags(kFunctionHasNonThisStmt, set); }
-    void SetHasReferenceableBuiltInArguments(bool set = true) { SetFlags(kFunctionHasReferencableBuiltInArguments, set); }
+    void SetHasReferenceableBuiltInArguments(bool set = true) { SetFlags(kFunctionHasReferenceableBuiltInArguments, set); }
     void SetHasSuperReference(bool set = true) { SetFlags(kFunctionHasSuperReference, set); }
     void SetHasDirectSuper(bool set = true) { SetFlags(kFunctionHasDirectSuper, set); }
-    void SetHasNewTargetReferene(bool set = true) { SetFlags(kFunctionHasNewTargetReference, set); }
+    void SetHasNewTargetReference(bool set = true) { SetFlags(kFunctionHasNewTargetReference, set); }
     void SetHasThisStmt(bool set = true) { SetFlags(kFunctionHasThisStmt, set); }
     void SetHasWithStmt(bool set = true) { SetFlags(kFunctionHasWithStmt, set); }
     void SetIsAccessor(bool set = true) { SetFlags(kFunctionIsAccessor, set); }
@@ -311,7 +311,7 @@ public:
     bool HasDestructuringPattern() const { return HasFlags(kFunctionHasDestructuringPattern); }
     bool HasHeapArguments() const { return true; /* HasFlags(kFunctionHasHeapArguments); Disabling stack arguments. Always return HeapArguments as True */ }
     bool HasOnlyThisStmts() const { return !HasFlags(kFunctionHasNonThisStmt); }
-    bool HasReferenceableBuiltInArguments() const { return HasFlags(kFunctionHasReferencableBuiltInArguments); }
+    bool HasReferenceableBuiltInArguments() const { return HasFlags(kFunctionHasReferenceableBuiltInArguments); }
     bool HasSuperReference() const { return HasFlags(kFunctionHasSuperReference); }
     bool HasDirectSuper() const { return HasFlags(kFunctionHasDirectSuper); }
     bool HasNewTargetReference() const { return HasFlags(kFunctionHasNewTargetReference); }

lib/Parser/rterrors.h

@@ -138,8 +138,8 @@ RT_ERROR_MSG(JSERR_NeedArrayOrArg, 5028, "%s is not an Array or arguments object
 RT_ERROR_MSG(JSERR_ArrayLengthConstructIncorrect, 5029, "", "Array length must be a finite positive integer", kjstRangeError, 0)
 RT_ERROR_MSG(JSERR_ArrayLengthAssignIncorrect, 5030, "", "Array length must be assigned a finite positive integer", kjstRangeError, 0)
 RT_ERROR_MSG(JSERR_NeedArrayObject, 5031, "%s is not an Array object", "Array object expected", kjstTypeError, 0)
-// RETIRED ECMACP removd ;; RT_ERROR_MSG(JSERR_NoCPEval,     5032, "", "'eval' is not available in the ECMA 327 Compact Profile",               kjstEvalError, 0)
-// RETIRED ECMACP removd ;; RT_ERROR_MSG(JSERR_NoCPFunction, 5033, "", "Function constructor is not available in the ECMA 327 Compact Profile", kjstEvalError, 0)
+// RETIRED ECMACP removed ;; RT_ERROR_MSG(JSERR_NoCPEval,     5032, "", "'eval' is not available in the ECMA 327 Compact Profile",               kjstEvalError, 0)
+// RETIRED ECMACP removed ;; RT_ERROR_MSG(JSERR_NoCPFunction, 5033, "", "Function constructor is not available in the ECMA 327 Compact Profile", kjstEvalError, 0)
 RT_ERROR_MSG(JSERR_JSONSerializeCircular, 5034, "", "Circular reference in value argument not supported", kjstError, 0)
 RT_ERROR_MSG(JSERR_JSONInvalidReplacer, 5035, "", "Invalid replacer argument", kjstError, 0)
 RT_ERROR_MSG(JSERR_InvalidAttributeTrue,5036,"'%s' attribute on the property descriptor cannot be set to 'true' on this object","",kjstTypeError, 0)
@@ -203,13 +203,13 @@ RT_ERROR_MSG(JSERR_TypedArray_NeedSource, 5086, "", "Invalid source in typed arr
 RT_ERROR_MSG(JSERR_This_NeedDataView, 5087, "", "'this' is not a DataView object", kjstTypeError, 0)
 RT_ERROR_MSG(JSERR_DataView_NeedArgument, 5088, "Required argument %s in DataView method is not specified", "Invalid arguments in DataView", kjstTypeError, 0)
 RT_ERROR_MSG(JSERR_DataView_InvalidOffset, 5089, "", "DataView operation access beyond specified buffer length",  kjstTypeError, 0)
-RT_ERROR_MSG(JSERR_DataView_InvalidArugment, 5090, "DataView constructor argument %s is invalid", "Invalid arguments in DataView", kjstRangeError, 0)
+RT_ERROR_MSG(JSERR_DataView_InvalidArgument, 5090, "DataView constructor argument %s is invalid", "Invalid arguments in DataView", kjstRangeError, 0)
 
 RT_ERROR_MSG(JSERR_InvalidFunctionSignature, 5091, "The function '%s' has an invalid signature and cannot be called", "invalid function signature", kjstTypeError, 0)
-RT_ERROR_MSG(JSERR_InvalidPropertySiganture, 5092, "The property '%s' has an invalid signature and cannot be accessed", "invalid property signature", kjstTypeError, 0)
+RT_ERROR_MSG(JSERR_InvalidPropertySignature, 5092, "The property '%s' has an invalid signature and cannot be accessed", "invalid property signature", kjstTypeError, 0)
 
-RT_ERROR_MSG(JSERR_InvalidRTCPropertyValueIn, 5093, "The runtimeclass %s that has Windows.Foundation.IPropertyValue as default interface is not supported as input parameter type", "invalid input parameter type", kjstTypeError, 0)
-RT_ERROR_MSG(JSERR_RTCInvalidRTCPropertyValueOut, 5094, "The object with interface Windows.Foundation.IPropertyValue that has runtimeclass name %s is not supported as out parameter", "invalid ouput parameter", kjstTypeError, 0)
+RT_ERROR_MSG(JSERR_InvalidRTCPropertyValueIn, 5093, "The runtimeclass %s that has Windows.Foundation.IPropertyValue as default interface is not supported as an input parameter type", "invalid input parameter type", kjstTypeError, 0)
+RT_ERROR_MSG(JSERR_RTCInvalidRTCPropertyValueOut, 5094, "The object with interface Windows.Foundation.IPropertyValue that has runtimeclass name %s is not supported as an output parameter", "invalid output parameter", kjstTypeError, 0)
 
 RT_ERROR_MSG(JSERR_AccessArgumentsRestricted, 5095, "", "Accessing the 'arguments' property is restricted in this context", kjstTypeError, 0)
 
@@ -259,9 +259,9 @@ RT_ERROR_MSG(JSERR_IntlNotAvailable, 5125, "", "Intl is not available.", kjstTyp
 RT_ERROR_MSG(JSERR_ArgumentOutOfRange, 5130, "%s: argument out of range", "argument out of range", kjstRangeError, 0)
 RT_ERROR_MSG(JSERR_ErrorOnNew, 5131, "", "Function is not a constructor", kjstTypeError, 0)
 RT_ERROR_MSG(JSERR_This_NeedArrayIterator, 5132, "%s: 'this' is not an Array Iterator object", "Array Iterator expected", kjstTypeError, 0) // {Locked="\'this\'"}
-RT_ERROR_MSG(JSERR_This_NeedMapIterator, 5133, "%s: 'this' is not an Map Iterator object", "Map Iterator expected", kjstTypeError, 0) // {Locked="\'this\'"}
-RT_ERROR_MSG(JSERR_This_NeedSetIterator, 5134, "%s: 'this' is not an Set Iterator object", "Set Iterator expected", kjstTypeError, 0) // {Locked="\'this\'"}
-RT_ERROR_MSG(JSERR_This_NeedStringIterator, 5135, "%s: 'this' is not an String Iterator object", "String Iterator expected", kjstTypeError, 0) // {Locked="\'this\'"}
+RT_ERROR_MSG(JSERR_This_NeedMapIterator, 5133, "%s: 'this' is not a Map Iterator object", "Map Iterator expected", kjstTypeError, 0) // {Locked="\'this\'"}
+RT_ERROR_MSG(JSERR_This_NeedSetIterator, 5134, "%s: 'this' is not a Set Iterator object", "Set Iterator expected", kjstTypeError, 0) // {Locked="\'this\'"}
+RT_ERROR_MSG(JSERR_This_NeedStringIterator, 5135, "%s: 'this' is not a String Iterator object", "String Iterator expected", kjstTypeError, 0) // {Locked="\'this\'"}
 
 RT_ERROR_MSG(JSERR_InvalidSpreadArgument, 5140, "%s: argument cannot be spread; expected Array or Object with a 'length' property", "Argument cannot be spread; expected Array or Object with a 'length' property", kjstTypeError, 0)
 RT_ERROR_MSG(JSERR_InvalidSpreadLength, 5141, "%s: argument cannot be spread; the 'length' property must be a number or convert to a number", "Argument cannot be spread; the 'length' property must be a number or convert to a number", kjstTypeError, 0)

lib/Runtime/Base/CrossSite.cpp

@@ -218,7 +218,7 @@ namespace Js
             }
         }
 
-        // We have a object marshaled, we need to keep track of the related script context
+        // We have an object marshaled, we need to keep track of the related script context
         // so optimization overrides can be updated as a group
         scriptContext->optimizationOverrides.Merge(&object->GetScriptContext()->optimizationOverrides);
 

lib/Runtime/Base/DelayLoadLibrary.cpp

@@ -14,8 +14,8 @@ SetProcessValidCallTargets(
     _In_ HANDLE hProcess,
     _In_ PVOID VirtualAddress,
     _In_ SIZE_T RegionSize,
-    _In_ ULONG NumberOfOffets,
-    _In_reads_(NumberOfOffets) PCFG_CALL_TARGET_INFO OffsetInformation
+    _In_ ULONG NumberOfOffsets,
+    _In_reads_(NumberOfOffsets) PCFG_CALL_TARGET_INFO OffsetInformation
     );
 #endif
 #endif
@@ -398,8 +398,8 @@ namespace Js
     BOOL DelayLoadWinCoreMemory::SetProcessCallTargets(_In_ HANDLE hProcess,
         _In_ PVOID VirtualAddress,
         _In_ SIZE_T RegionSize,
-        _In_ ULONG NumberOfOffets,
-        _In_reads_(NumberOfOffets) PCFG_CALL_TARGET_INFO OffsetInformation)
+        _In_ ULONG NumberOfOffsets,
+        _In_reads_(NumberOfOffsets) PCFG_CALL_TARGET_INFO OffsetInformation)
     {
 
 #if defined(DELAYLOAD_SET_CFG_TARGET)
@@ -415,12 +415,12 @@ namespace Js
             }
 
             Assert(m_pfnSetProcessValidCallTargets != nullptr);
-            return m_pfnSetProcessValidCallTargets(hProcess, VirtualAddress, RegionSize, NumberOfOffets, OffsetInformation);
+            return m_pfnSetProcessValidCallTargets(hProcess, VirtualAddress, RegionSize, NumberOfOffsets, OffsetInformation);
         }
 
         return FALSE;
 #else
-        return SetProcessValidCallTargets(hProcess, VirtualAddress, RegionSize, NumberOfOffets, OffsetInformation);
+        return SetProcessValidCallTargets(hProcess, VirtualAddress, RegionSize, NumberOfOffsets, OffsetInformation);
 #endif
     }
 #endif
@@ -491,7 +491,7 @@ namespace Js
         {
             if (m_pfnRoGetMetadataFile == nullptr)
             {
-                m_pfnRoGetMetadataFile = (PFNCWRoGetMettadataFile)GetFunction("RoGetMetaDataFile");
+                m_pfnRoGetMetadataFile = (PFNCWRoGetMetadataFile)GetFunction("RoGetMetaDataFile");
                 if (m_pfnRoGetMetadataFile == nullptr)
                 {
                     return E_UNEXPECTED;

lib/Runtime/Base/DelayLoadLibrary.h

@@ -112,8 +112,8 @@ namespace Js
             _Outptr_opt_ IMetaDataImport2 **metaDataImport,
             _Out_opt_ mdTypeDef *typeDefToken);
 
-        typedef FNCWRoGetMetaDataFile* PFNCWRoGetMettadataFile;
-        PFNCWRoGetMettadataFile m_pfnRoGetMetadataFile;
+        typedef FNCWRoGetMetaDataFile* PFNCWRoGetMetadataFile;
+        PFNCWRoGetMetadataFile m_pfnRoGetMetadataFile;
 
 
     public:
@@ -269,8 +269,8 @@ namespace Js
             _In_ HANDLE hProcess,
             _In_ PVOID VirtualAddress,
             _In_ SIZE_T RegionSize,
-            _In_ ULONG NumberOfOffets,
-            _In_reads_(NumberOfOffets) PCFG_CALL_TARGET_INFO OffsetInformation
+            _In_ ULONG NumberOfOffsets,
+            _In_reads_(NumberOfOffsets) PCFG_CALL_TARGET_INFO OffsetInformation
             );
     };
 #endif

lib/Runtime/Base/FunctionBody.cpp

@@ -1181,7 +1181,7 @@ namespace Js
         Assert(scriptContext->DeferredParsingThunk == ProfileDeferredParsingThunk
             || scriptContext->DeferredParsingThunk == DefaultDeferredParsingThunk);
 #ifdef PERF_COUNTERS
-        PERF_COUNTER_INC(Code, DeferedFunction);
+        PERF_COUNTER_INC(Code, DeferredFunction);
 #endif
         uint newFunctionNumber = scriptContext->GetThreadContext()->NewFunctionNumber();
         if (!sourceInfo->GetSourceContextInfo()->IsDynamic())
@@ -1696,7 +1696,7 @@ namespace Js
                 );
 
             this->Copy(funcBody);
-            PERF_COUNTER_DEC(Code, DeferedFunction);
+            PERF_COUNTER_DEC(Code, DeferredFunction);
 
             if (!this->GetSourceContextInfo()->IsDynamic())
             {
@@ -1961,7 +1961,7 @@ namespace Js
             );
 
         this->Copy(funcBody);
-        PERF_COUNTER_DEC(Code, DeferedFunction);
+        PERF_COUNTER_DEC(Code, DeferredFunction);
 
         if (!this->GetSourceContextInfo()->IsDynamic())
         {
@@ -2041,7 +2041,7 @@ namespace Js
             {
                 this->m_utf8SourceInfo->StopTrackingDeferredFunction(this->GetLocalFunctionId());
             }
-            PERF_COUNTER_DEC(Code, DeferedFunction);
+            PERF_COUNTER_DEC(Code, DeferredFunction);
         }
     }
 
@@ -2271,7 +2271,7 @@ namespace Js
             this->m_isEval = isEval;
             this->m_isDynamicFunction = isDynamicFunction;
 
-            // It would have been better if we detect and reject large source buffer eariler before parsing
+            // It would have been better if we detect and reject large source buffer earlier before parsing
             size_t cbMin = node->sxFnc.cbMin;
             size_t lengthInBytes = node->sxFnc.LengthInBytes();
             if (cbMin > UINT_MAX || lengthInBytes > UINT_MAX)
@@ -2460,7 +2460,7 @@ namespace Js
         }
         if(!!pnode->sxFnc.HasReferenceableBuiltInArguments() != this->HasReferenceableBuiltInArguments())
         {
-            OUTPUT_VERBOSE_TRACE(Js::DebuggerPhase, L"Referencable Built in args is different on debug reparse: %s(%s)\n", this->GetExternalDisplayName(), this->GetDebugNumberSet(debugStringBuffer));
+            OUTPUT_VERBOSE_TRACE(Js::DebuggerPhase, L"Referenceable Built in args is different on debug reparse: %s(%s)\n", this->GetExternalDisplayName(), this->GetDebugNumberSet(debugStringBuffer));
         }
 
         pnode->sxFnc.SetChildCallsEval(this->GetChildCallsEval());
@@ -2777,7 +2777,7 @@ namespace Js
                 regex::Interval* pSourceSpan = &(statementMaps->Item(i)->sourceSpan);
                 if (FunctionBody::IsDummyGlobalRetStatement(pSourceSpan))
                 {
-                    // Workaround for handling global return, which is a empty range.
+                    // Workaround for handling global return, which is an empty range.
                     continue;
                 }
 
@@ -7591,7 +7591,7 @@ namespace Js
     {
         // DisableJIT-TODO: Move this to be under if DYNAMIC_PROFILE
 #if ENABLE_NATIVE_CODEGEN
-        // (See also the FunctionBody member written in CaptureDymamicProfileState.)
+        // (See also the FunctionBody member written in CaptureDynamicProfileState.)
         this->savedPolymorphicCacheState = entryPointInfo->GetPendingPolymorphicCacheState();
         this->savedInlinerVersion = entryPointInfo->GetPendingInlinerVersion();
         this->savedImplicitCallsFlags = entryPointInfo->GetPendingImplicitCallFlags();

lib/Runtime/Base/FunctionBody.h

@@ -864,7 +864,7 @@ namespace Js
         void RecordInlineeFrameMap(JsUtil::List<NativeOffsetInlineeFramePair, ArenaAllocator>* tempInlineeFrameMap);
         InlineeFrameRecord* FindInlineeFrame(void* returnAddress);
         bool HasInlinees() { return this->frameHeight > 0; }
-        void DoLazyBailout(BYTE** addressOfeturnAddress, Js::FunctionBody* functionBody, const PropertyRecord* propertyRecord);
+        void DoLazyBailout(BYTE** addressOfReturnAddress, Js::FunctionBody* functionBody, const PropertyRecord* propertyRecord);
 #endif
 #if DBG_DUMP
      public:
@@ -2618,7 +2618,7 @@ namespace Js
 
         bool InstallProbe(int offset);
         bool UninstallProbe(int offset);
-        bool ProbeAtOffset(int offsest, OpCode* pOriginalOpcode);
+        bool ProbeAtOffset(int offset, OpCode* pOriginalOpcode);
 
         FunctionBody * Clone(ScriptContext *scriptContext, uint sourceIndex = Js::Constants::InvalidSourceIndex);
 

lib/Runtime/Base/ScriptContext.cpp

@@ -3054,7 +3054,7 @@ namespace Js
             // Set library to profile mode so that for built-ins all new instances of functions
             // are created with entry point set to the ProfileThunk.
             this->javascriptLibrary->SetProfileMode(true);
-            this->javascriptLibrary->SetDispatchProfile(true, DispatchProfileInoke);
+            this->javascriptLibrary->SetDispatchProfile(true, DispatchProfileInvoke);
             if (!calledDuringAttach)
             {
                 m_fTraceDomCall = TRUE; // This flag is always needed in DebugMode to wrap external functions with DebugProfileThunk
@@ -3802,7 +3802,7 @@ namespace Js
 
     HRESULT ScriptContext::OnScriptCompiled(PROFILER_TOKEN scriptId, PROFILER_SCRIPT_TYPE type, IUnknown *pIDebugDocumentContext)
     {
-        // TODO : can we do a delay send of these events or can we send a event before doing all this stuff that could calculate overhead?
+        // TODO : can we do a delay send of these events or can we send an event before doing all this stuff that could calculate overhead?
         Assert(m_pProfileCallback != NULL);
 
         OUTPUT_TRACE(Js::ScriptProfilerPhase, L"ScriptContext::OnScriptCompiled scriptId : %d, ScriptType : %d\n", scriptId, type);

lib/Runtime/Base/ScriptContext.h

@@ -358,7 +358,7 @@ namespace Js
         Js::JavascriptMethod DeferredParsingThunk;
         Js::JavascriptMethod DeferredDeserializationThunk;
         Js::JavascriptMethod DispatchDefaultInvoke;
-        Js::JavascriptMethod DispatchProfileInoke;
+        Js::JavascriptMethod DispatchProfileInvoke;
 
         typedef HRESULT (*GetDocumentContextFunction)(
             ScriptContext *pContext,
@@ -1065,7 +1065,7 @@ private:
         BOOL IsNumericPropertyId(PropertyId propertyId, uint32* value);
 
         void RegisterWeakReferenceDictionary(JsUtil::IWeakReferenceDictionary* weakReferenceDictionary);
-        void ResetWeakReferenceDicitionaryList() { weakReferenceDictionaryList.Reset(); }
+        void ResetWeakReferenceDictionaryList() { weakReferenceDictionaryList.Reset(); }
 
         BOOL ReserveStaticTypeIds(__in int first, __in int last);
         TypeId ReserveTypeIds(int count);

lib/Runtime/Base/ThreadContext.cpp

@@ -2227,7 +2227,7 @@ void
 ThreadContext::PreCollectionCallBack(CollectionFlags flags)
 {
 #ifdef PERF_COUNTERS
-    PHASE_PRINT_TESTTRACE1(Js::DeferParsePhase, L"TestTrace: deferparse - # of func: %d # deferparsed: %d\n", PerfCounter::CodeCounterSet::GetTotalFunctionCounter().GetValue(), PerfCounter::CodeCounterSet::GetDeferedFunctionCounter().GetValue());
+    PHASE_PRINT_TESTTRACE1(Js::DeferParsePhase, L"TestTrace: deferparse - # of func: %d # deferparsed: %d\n", PerfCounter::CodeCounterSet::GetTotalFunctionCounter().GetValue(), PerfCounter::CodeCounterSet::GetDeferredFunctionCounter().GetValue());
 #endif
     // This needs to be done before ClearInlineCaches since that method can empty the list of
     // script contexts with inline caches

lib/Runtime/Base/ThreadContext.h

@@ -1028,7 +1028,7 @@ public:
     void AddBuiltInPropertyRecord(const Js::PropertyRecord *propertyRecord);
 
     void GetOrAddPropertyId(__in LPCWSTR propertyName, __in int propertyNameLength, Js::PropertyRecord const** propertyRecord);
-    void GetOrAddPropertyId(JsUtil::CharacterBuffer<WCHAR> const& propertName, Js::PropertyRecord const** propertyRecord);
+    void GetOrAddPropertyId(JsUtil::CharacterBuffer<WCHAR> const& propertyName, Js::PropertyRecord const** propertyRecord);
     Js::PropertyRecord const * UncheckedAddPropertyId(JsUtil::CharacterBuffer<WCHAR> const& propertyName, bool bind, bool isSymbol = false);
     Js::PropertyRecord const * UncheckedAddPropertyId(__in LPCWSTR propertyName, __in int propertyNameLength, bool bind = false, bool isSymbol = false);
 

lib/Runtime/ByteCode/BackEndOpcodeAttr.cpp

@@ -38,7 +38,7 @@ enum OpCodeAttrEnum
     OpFastFldInstr              = 0x00004000,
     OpBailOutRec                = 0x00008000,
 
-    OpInlinableBuiltIn          = 0x00010000, // OpCode is an inlineable built-in, such as InlineMathSin, etc.
+    OpInlinableBuiltIn          = 0x00010000, // OpCode is an inlinable built-in, such as InlineMathSin, etc.
     OpNonIntTransfer            = 0x00020000, // OpCode may transfer a non-integer value from the non-constant source to the destination
     OpIsInt32                   = 0x00040000, // OpCode converts its srcs to int32 or a narrower int type, and produces an int32
     OpProducesNumber            = 0x00080000, // OpCode always produces a number

lib/Runtime/ByteCode/ByteCodeEmitter.cpp

@@ -6006,7 +6006,7 @@ void EmitDestructuredValueOrInitializer(ParseNodePtr lhsElementNode,
         byteCodeGenerator->Writer()->Br(end);
         byteCodeGenerator->Writer()->MarkLabel(useDefault);
 
-        Emit(initializer, byteCodeGenerator, funcInfo, false/*isContructorCall*/);
+        Emit(initializer, byteCodeGenerator, funcInfo, false/*isConstructorCall*/);
         byteCodeGenerator->Writer()->Reg2(Js::OpCode::Ld_A, rhsLocationTmp, initializer->location);
         funcInfo->ReleaseLoc(initializer);
 

lib/Runtime/ByteCode/ByteCodeGenerator.cpp

@@ -1929,7 +1929,7 @@ void ByteCodeGenerator::Generate(__in ParseNode *pnode, ulong grfscr, __in ByteC
 
 #ifdef PERF_COUNTERS
     PHASE_PRINT_TESTTRACE1(Js::DeferParsePhase, L"TestTrace: deferparse - # of func: %d # deferparsed: %d\n",
-        PerfCounter::CodeCounterSet::GetTotalFunctionCounter().GetValue(), PerfCounter::CodeCounterSet::GetDeferedFunctionCounter().GetValue());
+        PerfCounter::CodeCounterSet::GetTotalFunctionCounter().GetValue(), PerfCounter::CodeCounterSet::GetDeferredFunctionCounter().GetValue());
 #endif
 }
 
@@ -4387,7 +4387,7 @@ void CheckFuncAssignment(Symbol * sym, ParseNode * pnode2, ByteCodeGenerator * b
 
             // Need to always detect interleaving dynamic scope ('with') for assignments
             // as those may end up escaping into the 'with' scope.
-                // TODO: the with scope is marked as MustInstaniate late during byte code emit
+                // TODO: the with scope is marked as MustInstantiate late during byte code emit
                 // We could detect this using the loop above as well, by marking the with
             // scope as must instantiate early, this is just less risky of a fix for RTM.
 
@@ -4547,7 +4547,7 @@ void AssignRegisters(ParseNode *pnode, ByteCodeGenerator *byteCodeGenerator)
 
                 if (pnodeName->nop == knopVarDecl && pnodeName->sxVar.sym != nullptr)
                 {
-                    // Unlike in CheckFuncAssignemnt, we don't have check if there is a interleaving
+                    // Unlike in CheckFuncAssignment, we don't check for interleaving
                     // dynamic scope ('with') here, because we also generate direct assignment for
                     // function decl's names
 
@@ -4674,7 +4674,7 @@ void AssignRegisters(ParseNode *pnode, ByteCodeGenerator *byteCodeGenerator)
 
         if (nonLambdaFunc != func || (func->IsGlobalFunction() && (byteCodeGenerator->GetFlags() & fscrEval)))
         {
-            nonLambdaFunc->root->sxFnc.SetHasNewTargetReferene();
+            nonLambdaFunc->root->sxFnc.SetHasNewTargetReference();
             nonLambdaFunc->AssignNewTargetRegister();
             nonLambdaFunc->SetIsNewTargetLexicallyCaptured();
             nonLambdaFunc->GetBodyScope()->SetHasLocalInClosure(true);
@@ -4705,7 +4705,7 @@ void AssignRegisters(ParseNode *pnode, ByteCodeGenerator *byteCodeGenerator)
             {
                 func->AssignNewTargetRegister();
 
-                nonLambdaFunc->root->sxFnc.SetHasNewTargetReferene();
+                nonLambdaFunc->root->sxFnc.SetHasNewTargetReference();
                 nonLambdaFunc->AssignNewTargetRegister();
                 nonLambdaFunc->SetIsNewTargetLexicallyCaptured();
                 nonLambdaFunc->AssignUndefinedConstRegister();

lib/Runtime/ByteCode/ByteCodeSerializer.cpp

@@ -165,7 +165,7 @@ struct DefaultComparer<ByteBuffer*>
 
 struct IndexEntry
 {
-    BufferBuilderByte* isProprertyRecord;
+    BufferBuilderByte* isPropertyRecord;
     int id;
 };
 
@@ -174,7 +174,7 @@ struct IndexEntry
 struct StringIndexRecord
 {
     int offset;
-    bool isProprertyRecord;
+    bool isPropertyRecord;
 };
 #pragma pack(pop)
 
@@ -567,7 +567,7 @@ public:
             }
 
             // Get a pointer to the previous entry of isPropertyRecord
-            indexEntry.isProprertyRecord = static_cast<BufferBuilderByte*>(string16IndexTable.list->First());
+            indexEntry.isPropertyRecord = static_cast<BufferBuilderByte*>(string16IndexTable.list->First());
 
             // Subsequent strings indexes point one past the end. This way, the size is always computable by subtracting indexes.
             auto stringIndexEntry = Anew(alloc, BufferBuilderRelativeOffset, L"String16 Index", stringEntry, sizeInBytes);
@@ -584,7 +584,7 @@ public:
         // we set only if the transition is from false => true. Once it is a property record, it cannot go back.
         if(isPropertyRecord)
         {
-            indexEntry.isProprertyRecord->value = isPropertyRecord;
+            indexEntry.isPropertyRecord->value = isPropertyRecord;
         }
         return indexEntry.id;
     }
@@ -2570,7 +2570,7 @@ public:
         const unaligned StringIndexRecord* record = string16IndexTable + (id - this->expectedBuildInPropertyCount);
         if(isPropertyRecord)
         {
-            *isPropertyRecord = record->isProprertyRecord;
+            *isPropertyRecord = record->isPropertyRecord;
         }
         auto offset = record->offset;
         auto addressOfString = raw + offset;

lib/Runtime/ByteCode/ByteCodeSerializer.h

@@ -34,7 +34,7 @@ namespace Js
         sakIntArray = 5,
         sakFloatArray = 6,
 
-        sakPropertyIdArrayForCachedScope = 7,       // serialization only type, indiciate extra slots
+        sakPropertyIdArrayForCachedScope = 7,       // serialization only type, indicate extra slots
     };
 
 // Tightly pack serialized structures

lib/Runtime/ByteCode/ByteCodeWriter.cpp

@@ -2822,7 +2822,7 @@ StoreCommon:
 
     void ByteCodeWriter::EndStatement(ParseNode* node)
     {
-        AssertMsg(m_pMatchingNode, "EndStatement unmatched to StartStartment");
+        AssertMsg(m_pMatchingNode, "EndStatement unmatched to StartStatement");
         if (m_pMatchingNode != node)
         {
             return;
@@ -3169,7 +3169,7 @@ StoreCommon:
         }
         else
         {
-            ByteBlock* finalByteCodeBlock = ByteBlock::New(alloc, /*intialContent*/nullptr, cbFinalData);
+            ByteBlock* finalByteCodeBlock = ByteBlock::New(alloc, /*initialContent*/nullptr, cbFinalData);
 
             DataChunk* currentChunk = head;
             size_t bytesLeftToCopy = cbFinalData;

lib/Runtime/ByteCode/FuncInfo.h

@@ -92,7 +92,7 @@ public:
     uint        innerScopeCount;
     uint        currentInnerScopeIndex;
 #if DBG
-    uint32 outArgsDepth; // number of calls nested in a expression
+    uint32 outArgsDepth; // number of calls nested in an expression
 #endif
     const wchar_t *name; // name of the function
     Js::RegSlot nullConstantRegister; // location, if any, of enregistered null constant

lib/Runtime/ByteCode/OpCodes.h

@@ -608,7 +608,7 @@ MACRO_BACKEND_ONLY(     Coerse_Regex, Empty, OpCallsValueOf|OpHasImplicitCall|Op
 // Operation CreateRegex(regex) or CoerseStr(arg)
 MACRO_BACKEND_ONLY(     Coerse_StrOrRegex, Empty, OpCallsValueOf|OpHasImplicitCall|OpTempNumberSources|OpTempNumberTransfer|OpPostOpDbgBailOut)
 
-// Operation ToString(ToPrimtive(src1))
+// Operation ToString(ToPrimitive(src1))
 MACRO_BACKEND_ONLY(     Conv_PrimStr,       Empty,          OpCallsValueOf|OpHasImplicitCall|OpTempNumberSources|OpTempObjectSources|OpCanCSE|OpPostOpDbgBailOut)
 
 // The following are for lowering; currently the specified layout is not used

lib/Runtime/ByteCode/OpCodesAsmJs.h

@@ -90,7 +90,7 @@ MACRO_WMS   ( LdSlotArr                 , ElementSlot  , None            ) // Lo
 MACRO_WMS   ( LdSlot                    , ElementSlot  , None            ) // Loads a Var from an array of Var
 MACRO_WMS   ( LdSlot_Db                 , ElementSlot  , None            ) // Loads a double from the Module
 MACRO_WMS   ( LdSlot_Int                , ElementSlot  , None            ) // Loads an Int from the Module
-MACRO_WMS   ( LdSlot_Flt                , ElementSlot  , None            ) // Loads an Float from the Module
+MACRO_WMS   ( LdSlot_Flt                , ElementSlot  , None            ) // Loads a Float from the Module
 MACRO_WMS   ( StSlot_Db                 , ElementSlot  , None            ) // Sets a double in the Module
 MACRO_WMS   ( StSlot_Int                , ElementSlot  , None            ) // Sets an Int in the Module
 MACRO_WMS   ( StSlot_Flt                , ElementSlot  , None            ) // Sets an Int in the Module

lib/Runtime/Debug/DiagObjectModel.cpp

@@ -2326,7 +2326,7 @@ namespace Js
                     // If the object contains array indices.
                     if (typeId == TypeIds_Arguments)
                     {
-                        // Create ArgumentsArray walker for a arguments object
+                        // Create ArgumentsArray walker for an arguments object
 
                         Js::ArgumentsObject * argObj = static_cast<Js::ArgumentsObject*>(instance);
                         Assert(argObj);

lib/Runtime/Debug/DiagObjectModel.h

@@ -393,7 +393,7 @@ namespace Js
     // The locals var's addresses.
 
 
-    // A representation of a address when this Var is taken from the slot array.
+    // A representation of an address when this Var is taken from the slot array.
     class LocalObjectAddressForSlot : public IDiagObjectAddress
     {
         ScopeSlots slotArray;
@@ -408,7 +408,7 @@ namespace Js
         virtual BOOL IsInDeadZone() const;
     };
 
-    // A representation of a address when this Var is taken from the direct regslot.
+    // A representation of an address when this Var is taken from the direct regslot.
     class LocalObjectAddressForRegSlot : public IDiagObjectAddress
     {
         DiagStackFrame* pFrame;

lib/Runtime/Debug/DiagProbe.h

@@ -86,7 +86,7 @@ namespace Js
         STEP_OUT        = 0x04,
         STEP_DOCUMENT   = 0x08,
 
-        // On entry of an jitted function, need to bailout to handle stepping if in STEP_IN mode,
+        // On entry of a jitted function, need to bailout to handle stepping if in STEP_IN mode,
         // or STEP_OVER (e.g. STEP_OVER at the end of this function, and it is called again by a
         // library caller).
         STEP_BAILOUT    = STEP_IN | STEP_OVER,

lib/Runtime/Debug/ProbeContainer.h

@@ -42,7 +42,7 @@ namespace Js
 
         Var jsExceptionObject;
 
-        // Used for synchronizing with ProbeMananger
+        // Used for synchronizing with ProbeManager
         ulong debugSessionNumber;
 
         uint32  tmpRegCount; // Mentions the temp register count for the current statement (this will be used to determine if SetNextStatement can be applied)
@@ -54,7 +54,7 @@ namespace Js
         // Used when the throw is internal and engine does not want to be broken at exception.
         bool isThrowInternal;
 
-        // This variabled will be set true when we don't want to check for debug script engine being initialized.
+        // This variable will be set true when we don't want to check for debug script engine being initialized.
         bool forceBypassDebugEngine;
 
         bool isPrimaryBrokenToDebuggerContext;

lib/Runtime/Language/AsmJSBytecodeGenerator.cpp

@@ -118,7 +118,7 @@ namespace Js
         FunctionBody *funcBody = mFunction->GetFuncBody();
         funcBody->CreateConstantTable();
         Var* table = (Var*)funcBody->GetConstTable();
-        table += AsmJsFunctionMemory::RequiredVarConstants - 1; // we do -1 here as the VarConstant count is erobased calculation
+        table += AsmJsFunctionMemory::RequiredVarConstants - 1; // we do -1 here as the VarConstant count is zero-based calculation
 
         int* intTable = (int*)table;
         // int Return Register
@@ -256,7 +256,7 @@ namespace Js
             DefineLabels( );
             EmitAsmJsFunctionBody();
 
-            // Set that the function is asmjsFuntion in functionBody here so that Initialize ExecutionMode call later will check for that and not profile in asmjsMode
+            // Set that the function is asmjsFunction in functionBody here so that Initialize ExecutionMode call later will check for that and not profile in asmjsMode
             functionBody->SetIsAsmJsFunction(true);
             functionBody->SetIsAsmjsMode(true);
 
@@ -621,7 +621,7 @@ namespace Js
             throw AsmJsCompilationException( L"Variable declaration must happen at the top of the function" );
             break;
         case knopDot:
-            // To handle expr.signMask for now, until Bools are suppored.
+            // To handle expr.signMask for now, until Bools are supported.
             return EmitDotExpr(pnode);
         default:
             throw AsmJsCompilationException( L"Unhandled parse opcode for asm.js" );

lib/Runtime/Language/AsmJSLink.h

@@ -8,7 +8,7 @@ namespace Js{
 
     class ASMLink{
     public:
-        static bool CheckParams(ScriptContext* scriptContext, AsmJsModuleInfo* info , const Var stdlib, const Var foreigh, Var bufferView);
+        static bool CheckParams(ScriptContext* scriptContext, AsmJsModuleInfo* info , const Var stdlib, const Var foreign, Var bufferView);
     private:
         static bool CheckArrayBuffer(ScriptContext* scriptContext, const Var bufferView, const AsmJsModuleInfo* info);
         static bool CheckStdLib(ScriptContext* scriptContext, const AsmJsModuleInfo* info, const Var stdlib);

lib/Runtime/Language/AsmJSModule.h

@@ -10,7 +10,7 @@
 #define ASMSIMD_BUILTIN_SIZE (128)
 namespace Js {
     // ModuleCompiler encapsulates the compilation of an entire asm.js module. Over
-    // the course of an ModuleCompiler object's lifetime, many FunctionCompiler
+    // the course of a ModuleCompiler object's lifetime, many FunctionCompiler
     // objects will be created and destroyed in sequence, one for each function in
     // the module.
     //

lib/Runtime/Language/AsmJSTypes.h

@@ -183,7 +183,7 @@ namespace Js
     //   }
     //
     // the AsmJSCoercion of (1) is Signed (since | performs ToInt32) but, when
-    // translated to an VarType, the result is a plain Int since, as shown, it
+    // translated to a VarType, the result is a plain Int since, as shown, it
     // is legal to assign both Signed and Unsigned (or some other Int) values to
     // it. For (2), the AsmJSCoercion is also Signed but, when translated to an
     // RetType, the result is Signed since callers (asm.js and non-asm.js) can
@@ -223,7 +223,7 @@ namespace Js
         bool operator!=( AsmJsVarType rhs ) const;
     };
 
-    // Implements <: (subtype) operator when the RHS is an VarType
+    // Implements <: (subtype) operator when the RHS is a VarType
     static inline bool
         operator<=( AsmJsType lhs, AsmJsVarType rhs )
     {
@@ -957,7 +957,7 @@ namespace Js
         ArgSlot mArgSizesLength;
         uint * mArgSizes;
         ArgSlot mArgByteSize;
-        // offset in Byte from the beggining of the stack aka R0
+        // offset in Byte from the beginning of the stack aka R0
         int mIntByteOffset, mDoubleByteOffset, mFloatByteOffset;
         AsmJsRetType mReturnType;
 

lib/Runtime/Language/DynamicProfileInfo.h

@@ -356,7 +356,7 @@ namespace Js
         void RecordSwitchType(FunctionBody* body, ProfileId switchId, Var object);
         ValueType GetSwitchType(FunctionBody* body, ProfileId switchId) const;
 
-        void RecordCallSiteInfo(FunctionBody* functionBody, ProfileId callSiteId, FunctionInfo * calleeFunctionInfo, JavascriptFunction* calleeFunction, ArgSlot actualArgCount, bool isConstructorCall, InlineCacheIndex ldFldInlnlineCacheId = Js::Constants::NoInlineCacheIndex);
+        void RecordCallSiteInfo(FunctionBody* functionBody, ProfileId callSiteId, FunctionInfo * calleeFunctionInfo, JavascriptFunction* calleeFunction, ArgSlot actualArgCount, bool isConstructorCall, InlineCacheIndex ldFldInlineCacheId = Js::Constants::NoInlineCacheIndex);
         void RecordConstParameterAtCallSite(ProfileId callSiteId, int argNum);
         bool HasCallSiteInfo(FunctionBody* functionBody);
         bool HasCallSiteInfo(FunctionBody* functionBody, ProfileId callSiteId); // Does a particular callsite have ProfileInfo?

lib/Runtime/Language/DynamicProfileStorage.cpp

@@ -334,8 +334,8 @@ bool DynamicProfileStorage::Initialize()
 
         // -DynamicProfileInput
         //      Without other -DynamicProfile flags - enable in memory profile cache without exporting
-        //      With -DyanmicProfileCache           - override the dynamic profile cache file
-        //      With -DyanmicProfileCacheDir        - clear the dynamic profile cache directory
+        //      With -DynamicProfileCache           - override the dynamic profile cache file
+        //      With -DynamicProfileCacheDir        - clear the dynamic profile cache directory
 
         if (Js::Configuration::Global.flags.DynamicProfileInput != nullptr)
         {

lib/Runtime/Language/InterpreterLoop.inl

@@ -2,7 +2,7 @@
 // Copyright (C) Microsoft. All rights reserved.
 // Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
 //-------------------------------------------------------------------------------------------------------
-// Shared intepreter loop
+// Shared interpreter loop
 //
 // This holds the single definition of the interpreter loop.
 // It allows for configurable copies of the loop that do extra work without

lib/Runtime/Language/InterpreterStackFrame.cpp

@@ -25,9 +25,9 @@
 /// - X: Nothing
 ///
 /// Examples:
-/// - "A2toA1" reads two registers, each storing an Var, and writes a single
+/// - "A2toA1" reads two registers, each storing a Var, and writes a single
 ///   register with a new Var.
-/// - "A1I1toA2" reads two registers, first an Var and second an Int32, then
+/// - "A1I1toA2" reads two registers, first a Var and second an Int32, then
 ///   writes two Var registers.
 ///
 /// Although these could use lookup tables to standard OpLayout types, this
@@ -2497,14 +2497,14 @@ namespace Js
             if (!info->IsRuntimeProcessed())
             {
                 // don't reset entrypoint upon relinking
-                FunctionEntryPointInfo* entypointInfo = (FunctionEntryPointInfo*)scriptFuncObj->GetEntryPointInfo();
-                entypointInfo->SetIsAsmJSFunction(true);
-                entypointInfo->SetModuleAddress((uintptr_t)moduleMemoryPtr);
+                FunctionEntryPointInfo* entrypointInfo = (FunctionEntryPointInfo*)scriptFuncObj->GetEntryPointInfo();
+                entrypointInfo->SetIsAsmJSFunction(true);
+                entrypointInfo->SetModuleAddress((uintptr_t)moduleMemoryPtr);
 
 #if DYNAMIC_INTERPRETER_THUNK
                 if (!PHASE_ON1(AsmJsJITTemplatePhase))
                 {
-                    entypointInfo->address = AsmJsDefaultEntryThunk;
+                    entrypointInfo->address = AsmJsDefaultEntryThunk;
                 }
 #endif
             }

lib/Runtime/Language/JavascriptConversion.cpp

@@ -32,7 +32,7 @@ namespace Js
     }
 
     //ES5 9.11  Undefined, Null, Boolean, Number, String - return false
-    //If Object has an [[Call]] internal method, then return true, otherwise return false
+    //If Object has a [[Call]] internal method, then return true, otherwise return false
     bool JavascriptConversion::IsCallable(Var aValue)
     {
         if (!RecyclableObject::Is(aValue))
@@ -237,7 +237,7 @@ CommonNumber:
     template bool JavascriptConversion::SameValueCommon<true>(Var aLeft, Var aRight);
 
     //----------------------------------------------------------------------------
-    // ToObject() takes a value and converts it to a Object type
+    // ToObject() takes a value and converts it to an Object type
     // Implementation of ES5 9.9
     // The spec indicates that this method should throw a TypeError if the supplied value is Undefined or Null.
     // Our implementation returns FALSE in this scenario, expecting the caller to throw the TypeError.

lib/Runtime/Language/JavascriptExceptionOperators.cpp

@@ -561,7 +561,7 @@ namespace Js
     void JavascriptExceptionOperators::DbgCheckEHChain()
     {
 #if 0
-        // This debug check is disabled until we figure out how to trace an fs:0 chain if we throw from inside
+        // This debug check is disabled until we figure out how to trace a fs:0 chain if we throw from inside
         // a finally.
 
         void *currentFS0;

lib/Runtime/Language/JavascriptOperators.cpp

@@ -561,15 +561,15 @@ namespace Js
 
     BOOL JavascriptOperators::Greater_Full(Var aLeft,Var aRight,ScriptContext* scriptContext)
     {
-        return RelationalComparsionHelper(aRight, aLeft, scriptContext, false, false);
+        return RelationalComparisonHelper(aRight, aLeft, scriptContext, false, false);
     }
 
     BOOL JavascriptOperators::Less_Full(Var aLeft, Var aRight, ScriptContext* scriptContext)
     {
-        return RelationalComparsionHelper(aLeft, aRight, scriptContext, true, false);
+        return RelationalComparisonHelper(aLeft, aRight, scriptContext, true, false);
     }
 
-    BOOL JavascriptOperators::RelationalComparsionHelper(Var aLeft, Var aRight, ScriptContext* scriptContext, bool leftFirst, bool undefinedAs)
+    BOOL JavascriptOperators::RelationalComparisonHelper(Var aLeft, Var aRight, ScriptContext* scriptContext, bool leftFirst, bool undefinedAs)
     {
         TypeId typeId = JavascriptOperators::GetTypeId(aLeft);
 
@@ -9714,7 +9714,7 @@ CommonNumber:
             }
         }
 
-        return !RelationalComparsionHelper(aLeft, aRight, scriptContext, true, true);
+        return !RelationalComparisonHelper(aLeft, aRight, scriptContext, true, true);
     }
 
     BOOL JavascriptOperators::LessEqual(Var aLeft, Var aRight, ScriptContext* scriptContext)
@@ -9747,7 +9747,7 @@ CommonNumber:
             }
         }
 
-        return !RelationalComparsionHelper(aRight, aLeft, scriptContext, false, true);
+        return !RelationalComparisonHelper(aRight, aLeft, scriptContext, false, true);
     }
 
     BOOL JavascriptOperators::NotEqual(Var aLeft, Var aRight, ScriptContext* scriptContext)

lib/Runtime/Language/JavascriptOperators.h

@@ -209,7 +209,7 @@ namespace Js
         static BOOL IsUndefinedObject(Var instance);
         static BOOL IsUndefinedObject(Var instance, ScriptContext *scriptContext);
         static BOOL IsUndefinedObject(Var instance, RecyclableObject *libraryUndefined);
-        static BOOL IsUndefinedObject(Var isntance, JavascriptLibrary* library);
+        static BOOL IsUndefinedObject(Var instance, JavascriptLibrary* library);
         static BOOL IsAnyNumberValue(Var instance);
         static BOOL IsIterable(RecyclableObject* instance, ScriptContext* scriptContext);
         static BOOL IsClassConstructor(Var instance);
@@ -586,7 +586,7 @@ namespace Js
         static Var GetSpecies(RecyclableObject* constructor, ScriptContext* scriptContext);
 
     private:
-        static BOOL RelationalComparsionHelper(Var aLeft, Var aRight, ScriptContext* scriptContext, bool leftFirst, bool undefinedAs);
+        static BOOL RelationalComparisonHelper(Var aLeft, Var aRight, ScriptContext* scriptContext, bool leftFirst, bool undefinedAs);
 
         template <typename ArrayType>
         static void ObjectToNativeArray(ArrayType* arrayObject,

lib/Runtime/Language/JavascriptStackWalker.cpp

@@ -423,7 +423,7 @@ namespace Js
             else
             {
                 //Get the function from the interpreterFrame in jit loop body case
-                //This is exactly same as this->GetCurrentFunctionFromPhysicalFrame() if the interperterFrame is not
+                //This is exactly same as this->GetCurrentFunctionFromPhysicalFrame() if the interpreterFrame is not
                 //called from bailout path.
                 Assert(this->lastInternalFrameInfo.codeAddress);
                 function = this->interpreterFrame->GetJavascriptFunction();

lib/Runtime/Language/SIMDBool16x8Operation.cpp

@@ -21,7 +21,7 @@ namespace Js
 
     SIMDValue SIMDBool16x8Operation::OpBool16x8(const SIMDValue& v)
     {
-        // overload function with input paramter as SIMDValue for completeness
+        // overload function with input parameter as SIMDValue for completeness
         SIMDValue result;
         result = v;
         return result;

lib/Runtime/Language/SIMDBool16x8OperationX86X64.cpp

@@ -16,7 +16,7 @@ namespace Js
 
     SIMDValue SIMDBool16x8Operation::OpBool16x8(const SIMDValue& v)
     {
-        // overload function with input paramter as SIMDValue for completeness
+        // overload function with input parameter as SIMDValue for completeness
         SIMDValue result;
         result = v;
         return result;

lib/Runtime/Language/SIMDBool32x4Operation.cpp

@@ -21,7 +21,7 @@ namespace Js
 
     SIMDValue SIMDBool32x4Operation::OpBool32x4(const SIMDValue& v)
     {
-        // overload function with input paramter as SIMDValue for completeness
+        // overload function with input parameter as SIMDValue for completeness
         SIMDValue result;
         result = v;
         return result;

lib/Runtime/Language/SIMDBool32x4OperationX86X64.cpp

@@ -17,7 +17,7 @@ namespace Js
 
     SIMDValue SIMDBool32x4Operation::OpBool32x4(const SIMDValue& v)
     {
-        // overload function with input paramter as SIMDValue for completeness
+        // overload function with input parameter as SIMDValue for completeness
         SIMDValue result;
         result = v;
         return result;

lib/Runtime/Language/SIMDBool8x16Operation.cpp

@@ -20,7 +20,7 @@ namespace Js
 
     SIMDValue SIMDBool8x16Operation::OpBool8x16(const SIMDValue& v)
     {
-        // overload function with input paramter as SIMDValue for completeness
+        // overload function with input parameter as SIMDValue for completeness
         SIMDValue result;
         result = v;
         return result;

lib/Runtime/Language/SIMDBool8x16OperationX86X64.cpp

@@ -18,7 +18,7 @@ namespace Js
 
     SIMDValue SIMDBool8x16Operation::OpBool8x16(const SIMDValue& v)
     {
-        // overload function with input paramter as SIMDValue for completeness
+        // overload function with input parameter as SIMDValue for completeness
         SIMDValue result;
         result = v;
         return result;