- Mutlidimensional arrays can be created by nesting arrays: + Multidimensional arrays can be created by nesting arrays:
{#code_begin|test|multidimensional#} const std = @import("std"); @@ -2898,7 +2898,7 @@ fn bar(x: *const u3) u3 { } {#code_end#}- In this case, the function {#syntax#}bar{#endsyntax#} cannot be called becuse the pointer + In this case, the function {#syntax#}bar{#endsyntax#} cannot be called because the pointer to the non-ABI-aligned field mentions the bit offset, but the function expects an ABI-aligned pointer.
@@ -5549,7 +5549,7 @@ test "coerce to optionals" { } {#code_end#}
It works nested inside the {#link|Error Union Type#}, too:
- {#code_begin|test|test_corerce_optional_wrapped_error_union#} + {#code_begin|test|test_coerce_optional_wrapped_error_union#} const std = @import("std"); const expect = std.testing.expect; @@ -7669,7 +7669,7 @@ test "main" { } {#code_end#}- will ouput: + will output:
If all {#syntax#}@compileLog{#endsyntax#} calls are removed or @@ -7786,7 +7786,7 @@ test "main" { the tag value is used as the enumeration value.
- If there is only one possible enum value, the resut is a {#syntax#}comptime_int{#endsyntax#} + If there is only one possible enum value, the result is a {#syntax#}comptime_int{#endsyntax#} known at {#link|comptime#}.
{#see_also|@intToEnum#} @@ -8736,7 +8736,7 @@ fn doTheTest() !void { {#header_open|@sin#}{#syntax#}@sin(value: anytype) @TypeOf(value){#endsyntax#}
- Sine trigometric function on a floating point number. Uses a dedicated hardware instruction + Sine trigonometric function on a floating point number. Uses a dedicated hardware instruction when available.
@@ -8747,7 +8747,7 @@ fn doTheTest() !void { {#header_open|@cos#}
{#syntax#}@cos(value: anytype) @TypeOf(value){#endsyntax#}
- Cosine trigometric function on a floating point number. Uses a dedicated hardware instruction + Cosine trigonometric function on a floating point number. Uses a dedicated hardware instruction when available.
@@ -10325,7 +10325,7 @@ pub fn main() void {
Some C constructs cannot be translated to Zig - for example, goto, structs with bitfields, and token-pasting macros. Zig employs demotion to allow translation - to continue in the face of non-translateable entities. + to continue in the face of non-translatable entities.
Demotion comes in three varieties - {#link|opaque#}, extern, and @@ -10335,13 +10335,13 @@ pub fn main() void { Functions that contain opaque types or code constructs that cannot be translated will be demoted to {#syntax#}extern{#endsyntax#} declarations. - Thus, non-translateable types can still be used as pointers, and non-translateable functions + Thus, non-translatable types can still be used as pointers, and non-translatable functions can be called so long as the linker is aware of the compiled function.
{#syntax#}@compileError{#endsyntax#} is used when top-level definitions (global variables, function prototypes, macros) cannot be translated or demoted. Since Zig uses lazy analysis for - top-level declarations, untranslateable entities will not cause a compile error in your code unless + top-level declarations, untranslatable entities will not cause a compile error in your code unless you actually use them.
{#see_also|opaque|extern|@compileError#} @@ -10353,7 +10353,7 @@ pub fn main() void { can be translated to Zig. Macros that cannot be translated will be be demoted to {#syntax#}@compileError{#endsyntax#}. Note that C code which uses macros will be translated without any additional issues (since Zig operates on the pre-processed source - with macros expanded). It is merely the macros themselves which may not be translateable to + with macros expanded). It is merely the macros themselves which may not be translatable to Zig.Consider the following example:
@@ -10373,7 +10373,7 @@ pub export fn foo() c_int { } pub const MAKELOCAL = @compileError("unable to translate C expr: unexpected token .Equal"); // macro.c:1:9 {#code_end#} -Note that {#syntax#}foo{#endsyntax#} was translated correctly despite using a non-translateable +
Note that {#syntax#}foo{#endsyntax#} was translated correctly despite using a non-translatable
macro. {#syntax#}MAKELOCAL{#endsyntax#} was demoted to {#syntax#}@compileError{#endsyntax#} since
it cannot be expressed as a Zig function; this simply means that you cannot directly use
{#syntax#}MAKELOCAL{#endsyntax#} from Zig.
diff --git a/src/AstGen.zig b/src/AstGen.zig
index 14ad6c94a7..416584bee9 100644
--- a/src/AstGen.zig
+++ b/src/AstGen.zig
@@ -197,7 +197,7 @@ pub const ResultLoc = union(enum) {
none_or_ref,
/// The expression will be coerced into this type, but it will be evaluated as an rvalue.
ty: Zir.Inst.Ref,
- /// Same as `ty` but it is guaranteed that Sema will additionall perform the coercion,
+ /// Same as `ty` but it is guaranteed that Sema will additionally perform the coercion,
/// so no `as` instruction needs to be emitted.
coerced_ty: Zir.Inst.Ref,
/// The expression must store its result into this typed pointer. The result instruction
@@ -479,7 +479,7 @@ fn lvalExpr(gz: *GenZir, scope: *Scope, node: Ast.Node.Index) InnerError!Zir.Ins
return expr(gz, scope, .ref, node);
}
-/// Turn Zig AST into untyped ZIR istructions.
+/// Turn Zig AST into untyped ZIR instructions.
/// When `rl` is discard, ptr, inferred_ptr, or inferred_ptr, the
/// result instruction can be used to inspect whether it is isNoReturn() but that is it,
/// it must otherwise not be used.
diff --git a/src/Compilation.zig b/src/Compilation.zig
index 00a737c2be..ef762dae1e 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -812,7 +812,7 @@ pub fn create(gpa: *Allocator, options: InitOptions) !*Compilation {
const needs_c_symbols = !options.skip_linker_dependencies and is_exe_or_dyn_lib;
- // WASI-only. Resolve the optinal exec-model option, defaults to command.
+ // WASI-only. Resolve the optional exec-model option, defaults to command.
const wasi_exec_model = if (options.target.os.tag != .wasi) undefined else options.wasi_exec_model orelse .command;
const comp: *Compilation = comp: {
diff --git a/src/Liveness.zig b/src/Liveness.zig
index dd0899e745..4da5eaa284 100644
--- a/src/Liveness.zig
+++ b/src/Liveness.zig
@@ -30,7 +30,7 @@ tomb_bits: []usize,
/// The main tomb bits are still used and the extra ones are starting with the lsb of the
/// value here.
special: std.AutoHashMapUnmanaged(Air.Inst.Index, u32),
-/// Auxilliary data. The way this data is interpreted is determined contextually.
+/// Auxiliary data. The way this data is interpreted is determined contextually.
extra: []const u32,
/// Trailing is the set of instructions whose lifetimes end at the start of the then branch,
diff --git a/src/Module.zig b/src/Module.zig
index a6a9225d75..33d8f6b715 100644
--- a/src/Module.zig
+++ b/src/Module.zig
@@ -2188,39 +2188,39 @@ pub const LazySrcLoc = union(enum) {
node_offset_bin_op: i32,
/// The source location points to the LHS of a binary expression, found
/// by taking this AST node index offset from the containing Decl AST node,
- /// which points to a binary expression AST node. Next, nagivate to the LHS.
+ /// which points to a binary expression AST node. Next, navigate to the LHS.
/// The Decl is determined contextually.
node_offset_bin_lhs: i32,
/// The source location points to the RHS of a binary expression, found
/// by taking this AST node index offset from the containing Decl AST node,
- /// which points to a binary expression AST node. Next, nagivate to the RHS.
+ /// which points to a binary expression AST node. Next, navigate to the RHS.
/// The Decl is determined contextually.
node_offset_bin_rhs: i32,
/// The source location points to the operand of a switch expression, found
/// by taking this AST node index offset from the containing Decl AST node,
- /// which points to a switch expression AST node. Next, nagivate to the operand.
+ /// which points to a switch expression AST node. Next, navigate to the operand.
/// The Decl is determined contextually.
node_offset_switch_operand: i32,
/// The source location points to the else/`_` prong of a switch expression, found
/// by taking this AST node index offset from the containing Decl AST node,
- /// which points to a switch expression AST node. Next, nagivate to the else/`_` prong.
+ /// which points to a switch expression AST node. Next, navigate to the else/`_` prong.
/// The Decl is determined contextually.
node_offset_switch_special_prong: i32,
/// The source location points to all the ranges of a switch expression, found
/// by taking this AST node index offset from the containing Decl AST node,
- /// which points to a switch expression AST node. Next, nagivate to any of the
+ /// which points to a switch expression AST node. Next, navigate to any of the
/// range nodes. The error applies to all of them.
/// The Decl is determined contextually.
node_offset_switch_range: i32,
/// The source location points to the calling convention of a function type
/// expression, found by taking this AST node index offset from the containing
- /// Decl AST node, which points to a function type AST node. Next, nagivate to
+ /// Decl AST node, which points to a function type AST node. Next, navigate to
/// the calling convention node.
/// The Decl is determined contextually.
node_offset_fn_type_cc: i32,
/// The source location points to the return type of a function type
/// expression, found by taking this AST node index offset from the containing
- /// Decl AST node, which points to a function type AST node. Next, nagivate to
+ /// Decl AST node, which points to a function type AST node. Next, navigate to
/// the return type node.
/// The Decl is determined contextually.
node_offset_fn_type_ret_ty: i32,
diff --git a/src/Sema.zig b/src/Sema.zig
index cc7a227ca6..2fa12baca6 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -11164,7 +11164,7 @@ fn getBuiltinType(
}
/// There is another implementation of this in `Type.onePossibleValue`. This one
-/// in `Sema` is for calling during semantic analysis, and peforms field resolution
+/// in `Sema` is for calling during semantic analysis, and performs field resolution
/// to get the answer. The one in `Type` is for calling during codegen and asserts
/// that the types are already resolved.
fn typeHasOnePossibleValue(
@@ -11541,7 +11541,7 @@ fn analyzeComptimeAlloc(
/// The places where a user can specify an address space attribute
pub const AddressSpaceContext = enum {
- /// A function is specificed to be placed in a certain address space.
+ /// A function is specified to be placed in a certain address space.
function,
/// A (global) variable is specified to be placed in a certain address space.
@@ -11553,7 +11553,7 @@ pub const AddressSpaceContext = enum {
/// In contrast to .variable, values placed in this address space are not required to be mutable.
constant,
- /// A pointer is ascripted to point into a certian address space.
+ /// A pointer is ascripted to point into a certain address space.
pointer,
};
diff --git a/src/codegen.zig b/src/codegen.zig
index 06b520c9dd..56580f91e1 100644
--- a/src/codegen.zig
+++ b/src/codegen.zig
@@ -985,7 +985,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
// increasing the pc
const d_pc_p9 = @intCast(i64, delta_pc) - quant;
if (d_pc_p9 > 0) {
- // minus one becaue if its the last one, we want to leave space to change the line which is one quanta
+ // minus one because if its the last one, we want to leave space to change the line which is one quanta
try dbg_out.dbg_line.append(@intCast(u8, @divExact(d_pc_p9, quant) + 128) - quant);
if (dbg_out.pcop_change_index.*) |pci|
dbg_out.dbg_line.items[pci] += 1;
@@ -1919,15 +1919,15 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
},
.shl => {
assert(!swap_lhs_and_rhs);
- const shift_amout = switch (operand) {
+ const shift_amount = switch (operand) {
.Register => |reg_op| Instruction.ShiftAmount.reg(@intToEnum(Register, reg_op.rm)),
.Immediate => |imm_op| Instruction.ShiftAmount.imm(@intCast(u5, imm_op.imm)),
};
- writeInt(u32, try self.code.addManyAsArray(4), Instruction.lsl(.al, dst_reg, op1, shift_amout).toU32());
+ writeInt(u32, try self.code.addManyAsArray(4), Instruction.lsl(.al, dst_reg, op1, shift_amount).toU32());
},
.shr => {
assert(!swap_lhs_and_rhs);
- const shift_amout = switch (operand) {
+ const shift_amount = switch (operand) {
.Register => |reg_op| Instruction.ShiftAmount.reg(@intToEnum(Register, reg_op.rm)),
.Immediate => |imm_op| Instruction.ShiftAmount.imm(@intCast(u5, imm_op.imm)),
};
@@ -1936,7 +1936,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
.signed => Instruction.asr,
.unsigned => Instruction.lsr,
};
- writeInt(u32, try self.code.addManyAsArray(4), shr(.al, dst_reg, op1, shift_amout).toU32());
+ writeInt(u32, try self.code.addManyAsArray(4), shr(.al, dst_reg, op1, shift_amount).toU32());
},
else => unreachable, // not a binary instruction
}
@@ -3618,7 +3618,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
try self.blocks.putNoClobber(self.gpa, inst, .{
// A block is a setup to be able to jump to the end.
.relocs = .{},
- // It also acts as a receptical for break operands.
+ // It also acts as a receptacle for break operands.
// Here we use `MCValue.none` to represent a null value so that the first
// break instruction will choose a MCValue for the block result and overwrite
// this field. Following break instructions will use that MCValue to put their
@@ -3672,7 +3672,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
return self.fail("TODO: enable larger branch offset", .{});
}
},
- else => unreachable, // attempting to perfrom an ARM relocation on a non-ARM target arch
+ else => unreachable, // attempting to perform an ARM relocation on a non-ARM target arch
}
},
}
diff --git a/src/codegen/arm.zig b/src/codegen/arm.zig
index ec9152f96b..279ce58005 100644
--- a/src/codegen/arm.zig
+++ b/src/codegen/arm.zig
@@ -2,7 +2,7 @@ const std = @import("std");
const DW = std.dwarf;
const testing = std.testing;
-/// The condition field specifies the flags neccessary for an
+/// The condition field specifies the flags necessary for an
/// Instruction to be executed
pub const Condition = enum(u4) {
/// equal
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index 650628d8c2..b2b87b97d8 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -1161,7 +1161,7 @@ pub const FuncGen = struct {
/// in other instructions. This table is cleared before every function is generated.
func_inst_table: std.AutoHashMapUnmanaged(Air.Inst.Index, *const llvm.Value),
- /// These fields are used to refer to the LLVM value of the function paramaters
+ /// These fields are used to refer to the LLVM value of the function parameters
/// in an Arg instruction.
args: []*const llvm.Value,
arg_index: usize,
diff --git a/src/codegen/spirv.zig b/src/codegen/spirv.zig
index f5796b06bc..5826daa5a5 100644
--- a/src/codegen/spirv.zig
+++ b/src/codegen/spirv.zig
@@ -260,7 +260,7 @@ pub const DeclGen = struct {
};
}
- /// Generate the code for `decl`. If a reportable error occured during code generation,
+ /// Generate the code for `decl`. If a reportable error occurred during code generation,
/// a message is returned by this function. Callee owns the memory. If this function
/// returns such a reportable error, it is valid to be called again for a different decl.
pub fn gen(self: *DeclGen, decl: *Decl, air: Air, liveness: Liveness) !?*Module.ErrorMsg {
@@ -565,7 +565,7 @@ pub const DeclGen = struct {
}
},
// When recursively generating a type, we cannot infer the pointer's storage class. See genPointerType.
- .Pointer => return self.fail("Cannot create pointer with unkown storage class", .{}),
+ .Pointer => return self.fail("Cannot create pointer with unknown storage class", .{}),
.Vector => {
// Although not 100% the same, Zig vectors map quite neatly to SPIR-V vectors (including many integer and float operations
// which work on them), so simply use those.
diff --git a/src/codegen/wasm.zig b/src/codegen/wasm.zig
index bb05567236..9bd80f7d84 100644
--- a/src/codegen/wasm.zig
+++ b/src/codegen/wasm.zig
@@ -1005,7 +1005,7 @@ pub const Context = struct {
const rhs = self.resolveInst(bin_op.rhs);
// it's possible for both lhs and/or rhs to return an offset as well,
- // in which case we return the first offset occurance we find.
+ // in which case we return the first offset occurrence we find.
const offset = blk: {
if (lhs == .code_offset) break :blk lhs.code_offset;
if (rhs == .code_offset) break :blk rhs.code_offset;
@@ -1031,7 +1031,7 @@ pub const Context = struct {
const rhs = self.resolveInst(bin_op.rhs);
// it's possible for both lhs and/or rhs to return an offset as well,
- // in which case we return the first offset occurance we find.
+ // in which case we return the first offset occurrence we find.
const offset = blk: {
if (lhs == .code_offset) break :blk lhs.code_offset;
if (rhs == .code_offset) break :blk rhs.code_offset;
@@ -1395,7 +1395,7 @@ pub const Context = struct {
}
// We map every block to its block index.
- // We then determine how far we have to jump to it by substracting it from current block depth
+ // We then determine how far we have to jump to it by subtracting it from current block depth
const idx: u32 = self.block_depth - self.blocks.get(br.block_inst).?;
const writer = self.code.writer();
try writer.writeByte(wasm.opcode(.br));
diff --git a/src/link/Coff.zig b/src/link/Coff.zig
index fa234f608b..fd009ca9f8 100644
--- a/src/link/Coff.zig
+++ b/src/link/Coff.zig
@@ -50,7 +50,7 @@ last_text_block: ?*TextBlock = null,
section_table_offset: u32 = 0,
/// Section data file pointer.
section_data_offset: u32 = 0,
-/// Optiona header file pointer.
+/// Optional header file pointer.
optional_header_offset: u32 = 0,
/// Absolute virtual address of the offset table when the executable is loaded in memory.
@@ -602,7 +602,7 @@ fn writeOffsetTableEntry(self: *Coff, index: usize) !void {
const current_virtual_size = mem.alignForwardGeneric(u32, self.offset_table_size, section_alignment);
const new_virtual_size = mem.alignForwardGeneric(u32, new_raw_size, section_alignment);
// If we had to move in the virtual address space, we need to fix the VAs in the offset table, as well as the virtual address of the `.text` section
- // and the virutal size of the `.got` section
+ // and the virtual size of the `.got` section
if (new_virtual_size != current_virtual_size) {
log.debug("growing offset table from virtual size {} to {}\n", .{ current_virtual_size, new_virtual_size });
@@ -980,7 +980,7 @@ fn linkWithLLD(self: *Coff, comp: *Compilation) !void {
const full_out_path = try directory.join(arena, &[_][]const u8{self.base.options.emit.?.sub_path});
if (self.base.options.output_mode == .Obj) {
- // LLD's COFF driver does not support the equvialent of `-r` so we do a simple file copy
+ // LLD's COFF driver does not support the equivalent of `-r` so we do a simple file copy
// here. TODO: think carefully about how we can avoid this redundant operation when doing
// build-obj. See also the corresponding TODO in linkAsArchive.
const the_object_path = blk: {
diff --git a/src/link/MachO.zig b/src/link/MachO.zig
index e69b85ca7f..dc44474c0a 100644
--- a/src/link/MachO.zig
+++ b/src/link/MachO.zig
@@ -213,7 +213,7 @@ decls: std.AutoArrayHashMapUnmanaged(*Module.Decl, void) = .{},
/// Currently active Module.Decl.
/// TODO this might not be necessary if we figure out how to pass Module.Decl instance
-/// to codegen.genSetReg() or alterntively move PIE displacement for MCValue{ .memory = x }
+/// to codegen.genSetReg() or alternatively move PIE displacement for MCValue{ .memory = x }
/// somewhere else in the codegen.
active_decl: ?*Module.Decl = null,
@@ -512,7 +512,7 @@ pub fn flush(self: *MachO, comp: *Compilation) !void {
const full_out_path = try directory.join(arena, &[_][]const u8{self.base.options.emit.?.sub_path});
if (self.base.options.output_mode == .Obj) {
- // LLD's MachO driver does not support the equvialent of `-r` so we do a simple file copy
+ // LLD's MachO driver does not support the equivalent of `-r` so we do a simple file copy
// here. TODO: think carefully about how we can avoid this redundant operation when doing
// build-obj. See also the corresponding TODO in linkAsArchive.
const the_object_path = blk: {
@@ -2245,7 +2245,7 @@ pub fn createStubAtom(self: *MachO, laptr_sym_index: u32) !*Atom {
fn createTentativeDefAtoms(self: *MachO) !void {
if (self.tentatives.count() == 0) return;
// Convert any tentative definition into a regular symbol and allocate
- // text blocks for each tentative defintion.
+ // text blocks for each tentative definition.
while (self.tentatives.popOrNull()) |entry| {
const match = MatchingSection{
.seg = self.data_segment_cmd_index.?,
@@ -4609,7 +4609,7 @@ fn populateLazyBindOffsetsInStubHelper(self: *MachO, buffer: []const u8) !void {
// Because we insert lazy binding opcodes in reverse order (from last to the first atom),
// we need reverse the order of atom traversal here as well.
- // TODO figure out a less error prone mechanims for this!
+ // TODO figure out a less error prone mechanisms for this!
var atom = last_atom;
while (atom.prev) |prev| {
atom = prev;
diff --git a/src/link/MachO/Atom.zig b/src/link/MachO/Atom.zig
index bb6730fe0f..46e5191ab3 100644
--- a/src/link/MachO/Atom.zig
+++ b/src/link/MachO/Atom.zig
@@ -41,7 +41,7 @@ code: std.ArrayListUnmanaged(u8) = .{},
size: u64,
/// Alignment of this atom as a power of 2.
-/// For instance, aligmment of 0 should be read as 2^0 = 1 byte aligned.
+/// For instance, alignment of 0 should be read as 2^0 = 1 byte aligned.
alignment: u32,
/// List of relocations belonging to this atom.
diff --git a/src/link/MachO/Trie.zig b/src/link/MachO/Trie.zig
index 7bf451f2c8..c166aaf432 100644
--- a/src/link/MachO/Trie.zig
+++ b/src/link/MachO/Trie.zig
@@ -506,7 +506,7 @@ test "write Trie to a byte stream" {
});
try trie.finalize(gpa);
- try trie.finalize(gpa); // Finalizing mulitple times is a nop subsequently unless we add new nodes.
+ try trie.finalize(gpa); // Finalizing multiple times is a nop subsequently unless we add new nodes.
const exp_buffer = [_]u8{
0x0, 0x1, // node root
diff --git a/src/link/Plan9/aout.zig b/src/link/Plan9/aout.zig
index f3570f880c..39994516fa 100644
--- a/src/link/Plan9/aout.zig
+++ b/src/link/Plan9/aout.zig
@@ -16,7 +16,7 @@ pub const ExecHdr = extern struct {
comptime {
assert(@sizeOf(@This()) == 32);
}
- /// It is up to the caller to disgard the last 8 bytes if the header is not fat.
+ /// It is up to the caller to discard the last 8 bytes if the header is not fat.
pub fn toU8s(self: *@This()) [40]u8 {
var buf: [40]u8 = undefined;
var i: u8 = 0;
diff --git a/src/link/SpirV.zig b/src/link/SpirV.zig
index 17b656a06c..f9d3f7a1e6 100644
--- a/src/link/SpirV.zig
+++ b/src/link/SpirV.zig
@@ -12,7 +12,7 @@
//! - OpName and OpMemberName instructions.
//! - OpModuleProcessed instructions.
//! All annotation (decoration) instructions.
-//! All type declaration instructions, constant instructions, global variable declarations, (preferrably) OpUndef instructions.
+//! All type declaration instructions, constant instructions, global variable declarations, (preferably) OpUndef instructions.
//! All function declarations without a body (extern functions presumably).
//! All regular functions.
@@ -93,7 +93,7 @@ pub fn openPath(allocator: *Allocator, sub_path: []const u8, options: link.Optio
if (options.use_llvm) return error.LLVM_BackendIsTODO_ForSpirV; // TODO: LLVM Doesn't support SpirV at all.
if (options.use_lld) return error.LLD_LinkingIsTODO_ForSpirV; // TODO: LLD Doesn't support SpirV at all.
- // TODO: read the file and keep vaild parts instead of truncating
+ // TODO: read the file and keep valid parts instead of truncating
const file = try options.emit.?.directory.handle.createFile(sub_path, .{ .truncate = true, .read = true });
errdefer file.close();
diff --git a/src/link/Wasm.zig b/src/link/Wasm.zig
index 3de1fb49cc..a75ad1b2f7 100644
--- a/src/link/Wasm.zig
+++ b/src/link/Wasm.zig
@@ -35,7 +35,7 @@ llvm_object: ?*LlvmObject = null,
/// TODO: can/should we access some data structure in Module directly?
funcs: std.ArrayListUnmanaged(*Module.Decl) = .{},
/// List of all extern function Decls to be written to the `import` section of the
-/// wasm binary. The positin in the list defines the function index
+/// wasm binary. The position in the list defines the function index
ext_funcs: std.ArrayListUnmanaged(*Module.Decl) = .{},
/// When importing objects from the host environment, a name must be supplied.
/// LLVM uses "env" by default when none is given. This would be a good default for Zig
@@ -714,7 +714,7 @@ fn linkWithLLD(self: *Wasm, comp: *Compilation) !void {
const full_out_path = try directory.join(arena, &[_][]const u8{self.base.options.emit.?.sub_path});
if (self.base.options.output_mode == .Obj) {
- // LLD's WASM driver does not support the equvialent of `-r` so we do a simple file copy
+ // LLD's WASM driver does not support the equivalent of `-r` so we do a simple file copy
// here. TODO: think carefully about how we can avoid this redundant operation when doing
// build-obj. See also the corresponding TODO in linkAsArchive.
const the_object_path = blk: {
@@ -756,7 +756,7 @@ fn linkWithLLD(self: *Wasm, comp: *Compilation) !void {
if (self.base.options.output_mode == .Exe) {
// Increase the default stack size to a more reasonable value of 1MB instead of
- // the default of 1 Wasm page being 64KB, unless overriden by the user.
+ // the default of 1 Wasm page being 64KB, unless overridden by the user.
try argv.append("-z");
const stack_size = self.base.options.stack_size_override orelse 1048576;
const arg = try std.fmt.allocPrint(arena, "stack-size={d}", .{stack_size});
diff --git a/src/stage1/analyze.cpp b/src/stage1/analyze.cpp
index 320d8ff9b2..ec4ff8fc9e 100644
--- a/src/stage1/analyze.cpp
+++ b/src/stage1/analyze.cpp
@@ -6804,7 +6804,7 @@ static Error resolve_async_frame(CodeGen *g, ZigType *frame_type) {
// Since this frame is async, an await might represent a suspend point, and
// therefore need to spill. It also needs to mark expr scopes as having to spill.
// For example: foo() + await z
- // The funtion call result of foo() must be spilled.
+ // The function call result of foo() must be spilled.
for (size_t i = 0; i < fn->await_list.length; i += 1) {
Stage1AirInstAwait *await = fn->await_list.at(i);
if (await->is_nosuspend) {
diff --git a/src/stage1/ir.cpp b/src/stage1/ir.cpp
index 87dfee1bf2..b853961beb 100644
--- a/src/stage1/ir.cpp
+++ b/src/stage1/ir.cpp
@@ -6374,7 +6374,7 @@ static Stage1AirInst *ir_analyze_enum_to_union(IrAnalyze *ira, Scope *scope, Ast
if (target->value->type->data.enumeration.non_exhaustive) {
ir_add_error_node(ira, source_node,
- buf_sprintf("runtime cast to union '%s' from non-exhustive enum",
+ buf_sprintf("runtime cast to union '%s' from non-exhaustive enum",
buf_ptr(&wanted_type->name)));
return ira->codegen->invalid_inst_gen;
}
@@ -15189,7 +15189,7 @@ static Stage1AirInst *ir_analyze_container_field_ptr(IrAnalyze *ira, Buf *field_
return ir_analyze_inferred_field_ptr(ira, field_name, scope, source_node, container_ptr, bare_type);
}
- // Tracks wether we should return an undefined value of the correct type.
+ // Tracks whether we should return an undefined value of the correct type.
// We do this if the container pointer is undefined and we are in a TypeOf call.
bool return_undef = container_ptr->value->special == ConstValSpecialUndef && \
get_scope_typeof(scope) != nullptr;
@@ -15248,7 +15248,7 @@ static Stage1AirInst *ir_analyze_container_field_ptr(IrAnalyze *ira, Buf *field_
if (type_is_invalid(union_val->type))
return ira->codegen->invalid_inst_gen;
- // Reject undefined values unless we're intializing the union:
+ // Reject undefined values unless we're initializing the union:
// a undefined union means also the tag is undefined, accessing
// its payload slot is UB.
const UndefAllowed allow_undef = initializing ? UndefOk : UndefBad;
diff --git a/src/stage1/ir_print.cpp b/src/stage1/ir_print.cpp
index 152221926d..a76d3e4d5a 100644
--- a/src/stage1/ir_print.cpp
+++ b/src/stage1/ir_print.cpp
@@ -558,7 +558,7 @@ const char* ir_inst_gen_type_str(Stage1AirInstId id) {
case Stage1AirInstIdWasmMemoryGrow:
return "GenWasmMemoryGrow";
case Stage1AirInstIdExtern:
- return "GenExtrern";
+ return "GenExtern";
}
zig_unreachable();
}
@@ -829,7 +829,7 @@ static const char *cast_op_str(CastOp op) {
case CastOpIntToFloat: return "IntToFloat";
case CastOpFloatToInt: return "FloatToInt";
case CastOpBoolToInt: return "BoolToInt";
- case CastOpNumLitToConcrete: return "NumLitToConcrate";
+ case CastOpNumLitToConcrete: return "NumLitToConcrete";
case CastOpErrSet: return "ErrSet";
case CastOpBitCast: return "BitCast";
}
diff --git a/src/stage1/parser.cpp b/src/stage1/parser.cpp
index b06a944172..f7061bb232 100644
--- a/src/stage1/parser.cpp
+++ b/src/stage1/parser.cpp
@@ -2073,7 +2073,7 @@ static AstNode *ast_parse_field_init(ParseContext *pc) {
return nullptr;
}
if (eat_token_if(pc, TokenIdEq) == 0) {
- // Because ".Name" can also be intepreted as an enum literal, we should put back
+ // Because ".Name" can also be interpreted as an enum literal, we should put back
// those two tokens again so that the parser can try to parse them as the enum
// literal later.
put_back_token(pc);
diff --git a/src/type.zig b/src/type.zig
index f2fe9e4ccb..4a0f2a0536 100644
--- a/src/type.zig
+++ b/src/type.zig
@@ -3419,7 +3419,7 @@ pub const Type = extern union {
anyerror_void_error_union,
generic_poison,
/// This is a special type for variadic parameters of a function call.
- /// Casts to it will validate that the type can be passed to a c calling convetion function.
+ /// Casts to it will validate that the type can be passed to a c calling convention function.
var_args_param,
/// Same as `empty_struct` except it has an empty namespace.
empty_struct_literal,
diff --git a/src/windows_com.hpp b/src/windows_com.hpp
index f9833e0912..5f0f5565f7 100644
--- a/src/windows_com.hpp
+++ b/src/windows_com.hpp
@@ -352,7 +352,7 @@ extern "C" {
///