comment grammar tweaks

spelling and spacing

parameter singular

space after # when not an issue number

typo fix "explicity"

fix a bad SparseMatrix find-replace in a comment

fix 'situtations' typo

Author: tkelman

base/multidimensional.jl

@@ -493,7 +493,7 @@ rcum_promote_type{T}(op, ::Type{T}) = T
 rcum_promote_type{T,N}(op, ::Type{Array{T,N}}) = Array{rcum_promote_type(op,T), N}
 
 # accumulate_pairwise slightly slower then accumulate, but more numerically
-# stable in certain situtations (e.g. sums).
+# stable in certain situations (e.g. sums).
 # it does double the number of operations compared to accumulate,
 # though for cheap operations like + this does not have much impact (20%)
 function _accumulate_pairwise!{T, Op}(op::Op, c::AbstractVector{T}, v::AbstractVector, s, i1, n)::T

base/profile.jl

@@ -115,7 +115,7 @@ The keyword arguments can be any combination of:
    sorts in order of number of collected samples.
 
  - `noisefloor` only shows frames that exceed the heuristic noise floor of the sample (only applies to format `:tree`).
-   A suggested value to try for this is 2.0 (the default is 0). This parameters hides samples for which `n <= noisefloor * √N`,
+   A suggested value to try for this is 2.0 (the default is 0). This parameter hides samples for which `n <= noisefloor * √N`,
    where `n` is the number of samples on this line, and `N` is the number of samples for the callee.
 
  - `mincount` can also be used to limit the printout to only those

doc/src/manual/modules.md

@@ -233,7 +233,7 @@ imports, the Julia build, files it includes, or explicit dependencies declared b
 in the module file(s).
 
 For file dependencies, a change is determined by examining whether the modification time (mtime)
-of each file loaded by `include` or added explicity by `include_dependency` is unchanged, or equal
+of each file loaded by `include` or added explicitly by `include_dependency` is unchanged, or equal
 to the modification time truncated to the nearest second (to accommodate systems that can't copy
 mtime with sub-second accuracy). It also takes into account whether the path to the file chosen
 by the search logic in `require` matches the path that had created the precompile file.

src/ccall.cpp

@@ -146,10 +146,10 @@ static Value *runtime_sym_lookup(PointerType *funcptype, const char *f_lib,
     Constant *initnul = ConstantPointerNull::get((PointerType*)T_pvoidfunc);
     LoadInst *llvmf_orig = builder.CreateAlignedLoad(llvmgv, sizeof(void*));
     // This in principle needs a consume ordering so that load from
-    // this pointer sees valid value. However, this is not supported by
+    // this pointer sees a valid value. However, this is not supported by
     // LLVM (or agreed on in the C/C++ standard FWIW) and should be
     // almost impossible to happen on every platform we support since this
-    // ordering is enforced by the hardware and LLVM has to speculate a
+    // ordering is enforced by the hardware and LLVM has to speculate an
     // invalid load from the `cglobal` but doesn't depend on the `cglobal`
     // value for this to happen.
     // llvmf_orig->setAtomic(AtomicOrdering::Consume);
@@ -324,7 +324,7 @@ static Value *emit_plt(FunctionType *functype, const AttributeSet &attrs,
     GlobalVariable *got = prepare_global(shadowgot);
     LoadInst *got_val = builder.CreateAlignedLoad(got, sizeof(void*));
     // See comment in `runtime_sym_lookup` above. This in principle needs a
-    // consume ordering too. This is even less likely to cause issue though
+    // consume ordering too. This is even less likely to cause issues though
     // since the only thing we do to this loaded pointer is to call it
     // immediately.
     // got_val->setAtomic(AtomicOrdering::Consume);

src/codegen.cpp

@@ -3862,7 +3862,7 @@ static Function *gen_cfun_wrapper(jl_function_t *ff, jl_value_t *jlrettype, jl_t
 
         // figure out how to repack this type
         if (!specsig) {
-            Value *arg = boxed(inputarg, &ctx, false); // don't want a gcroot, since it's about to be but into the jlcall frame anyways
+            Value *arg = boxed(inputarg, &ctx, false); // don't want a gcroot, since it's about to be put into the jlcall frame anyways
             GetElementPtrInst *slot = GetElementPtrInst::Create(LLVM37_param(NULL) myargs,
                     ArrayRef<Value*>(ConstantInt::get(T_int32, FParamIndex)));
             slot->insertAfter(ctx.ptlsStates);
@@ -6034,7 +6034,7 @@ static inline std::string getNativeTarget()
 {
     std::string cpu = sys::getHostCPUName();
 #if defined(_CPU_ARM_)
-    // Try slightly harder than LLVM at determine the CPU architecture.
+    // Try slightly harder than LLVM at determining the CPU architecture.
     if (cpu == "generic") {
         // This is the most reliable way I can find
         // `/proc/cpuinfo` changes between kernel versions

src/jitlayers.cpp

@@ -756,9 +756,9 @@ static void jl_merge_module(Module *dest, std::unique_ptr<Module> src)
     }
 }
 
-// to finalizing a function, look up its name in the `module_for_fname` map of unfinalized functions
-// and merge it, plus any other modules it depends upon, into `collector`
-// then add `collector` to the execution engine
+// to finalize a function, look up its name in the `module_for_fname` map of
+// unfinalized functions and merge it, plus any other modules it depends upon,
+// into `collector` then add `collector` to the execution engine
 static StringMap<Module*> module_for_fname;
 static void jl_merge_recursive(Module *m, Module *collector);
 

src/llvm-gcroot.cpp

@@ -248,8 +248,8 @@ void JuliaGCAllocator::lowerHandlers()
     typedef std::map<CallInst*,HandlerData>::iterator hdlr_iter_t;
     // For each exception enter, compute the life time of the enter, find
     // the corresponding leaves and collect a list of nested exception frames.
-    // This assumes the exception frames has simple structure. E.g.
-    // there's no recursion and different frames do no share the same leave.
+    // This assumes the exception frames have simple structure. E.g.
+    // there's no recursion and different frames do not share the same leave.
     std::function<void(hdlr_iter_t)> process_handler = [&] (hdlr_iter_t hdlr) {
         auto enter = hdlr->first;
         auto &data = hdlr->second;
@@ -338,7 +338,7 @@ void JuliaGCAllocator::lowerHandlers()
     Value *handler_sz = ConstantInt::get(T_int32, sizeof(jl_handler_t));
     // Now allocate the stack slots.
     // At each iteration, we allocate a new handler and assign all the remaining
-    // frames that doesn't have a non-processed child to this handler.
+    // frames that don't have a non-processed child to this handler.
     Instruction *firstInst = &F.getEntryBlock().front();
     while (!handlers.empty()) {
         processing.clear();

src/signals-unix.c

@@ -76,7 +76,7 @@ static inline __attribute__((unused)) uintptr_t jl_get_rsp_from_ctx(const void *
 static void jl_call_in_ctx(jl_ptls_t ptls, void (*fptr)(void), void *_ctx)
 {
     // Modifying the ucontext should work but there is concern that
-    // sigreturn orientated programming mitigation can work against us
+    // sigreturn oriented programming mitigation can work against us
     // by rejecting ucontext that is modified.
     // The current (staged) implementation in the Linux Kernel only
     // checks that the syscall is made in the signal handler and that

test/TestHelpers.jl

@@ -31,7 +31,7 @@ function open_fake_pty()
         ccall(:ptsname, Ptr{UInt8}, (Cint,), fdm), O_RDWR|O_NOCTTY)
 
     # slave
-    slave   = RawFD(fds)
+    slave = RawFD(fds)
     master = Base.TTY(RawFD(fdm); readable = true)
     slave, master
 end

test/abstractarray.jl

@@ -746,17 +746,17 @@ let
     @test !issparse(m2)
 end
 
-#isinteger and isreal
+# isinteger and isreal
 @test isinteger(Diagonal(rand(1:5,5)))
 @test isreal(Diagonal(rand(5)))
 
-#unary ops
+# unary ops
 let A = Diagonal(rand(1:5,5))
     @test +(A) == A
     @test *(A) == A
 end
 
-#flipdim on empty
+# flipdim on empty
 @test flipdim(Diagonal([]),1) == Diagonal([])
 
 # ndims and friends

test/arrayops.jl

@@ -1,6 +1,6 @@
 # This file is a part of Julia. License is MIT: http://julialang.org/license
 
-#Array test
+# Array test
 
 @testset "basics" begin
     @test length([1, 2, 3]) == 3
@@ -431,7 +431,7 @@ end
     @test findmin([3.2,1.8,NaN,2.0]) == (1.8,2)
     @test findmax([3.2,1.8,NaN,2.0]) == (3.2,1)
 
-    # #14085
+    #14085
     @test findmax(4:9) == (9,6)
     @test indmax(4:9) == 6
     @test findmin(4:9) == (4,1)
@@ -444,14 +444,14 @@ end
 
 @testset "permutedims" begin
 
-    #keeps the num of dim
+    # keeps the num of dim
     p = randperm(5)
     q = randperm(5)
     a = rand(p...)
     b = permutedims(a,q)
     @test isequal(size(b), tuple(p[q]...))
 
-    #hand made case
+    # hand made case
     y = zeros(1,2,3)
     for i = 1:6
         y[i]=i
@@ -463,7 +463,7 @@ end
         z[i+3] = i*2
     end
 
-    #permutes correctly
+    # permutes correctly
     @test isequal(z,permutedims(y,[3,1,2]))
     @test isequal(z,permutedims(y,(3,1,2)))
 

test/file.jl

@@ -862,7 +862,7 @@ if !is_windows()
 
         # mv ----------------------------------------------------
         # move all 4 existing dirs
-        # As expected this will leave some absolute links brokern #11145#issuecomment-99315168
+        # As expected this will leave some absolute links broken #11145#issuecomment-99315168
         for d in [copytodir, maindir_new, maindir_new_keepsym, maindir]
             d_mv = joinpath(dirname(d), "$(basename(d))_mv")
             mv(d, d_mv; remove_destination=true)

test/libgit2.jl

@@ -751,7 +751,7 @@ mktempdir() do dir
                                 finalize(repo)
                             end
                             """
-                            # We try to be helpful by desparately looking for
+                            # We try to be helpful by desperately looking for
                             # a way to prompt the password interactively. Pretend
                             # to be a TTY to suppress those shenanigans. Further, we
                             # need to detach and change the controlling terminal with

test/sparse/sparsevector.jl

@@ -1041,7 +1041,7 @@ let testdims = (10, 20, 30), nzprob = 0.4, targetnumposzeros = 5, targetnumnegze
     @test exact_equal(xdrop, SparseVector(7, [1, 3, 5, 7], [3, -1., -2., 3.]))
 end
 
-# It's tempting to share data between a SparseVector and a SparseArrays,
+# It's tempting to share data between a SparseVector and a SparseMatrix,
 # but if that's done, then modifications to one or the other will cause
 # an inconsistent state:
 sv = sparse(1:10)