nielsbross/Ink-Shader-Language
1
0
Fork 0
Code Issues 2 Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: nielsbross:dev
Branches Tags
nielsbross:main nielsbross:new-builtins nielsbross:dev
..
compare: nielsbross:1adb289c10dca8d00e3670a5c730d5173e12b6e7
Branches Tags
nielsbross:main nielsbross:new-builtins nielsbross:dev

6 Commits
dev ... 1adb289c10

Author SHA1 Message Date
Niels Bross
1adb289c10 Add error propagation to lexer. 2025-01-06 22:17:44 +01:00
Niels Bross
d65c6359db Fixed some sem check init. 2025-01-05 22:38:08 +01:00
Niels Bross
d08529a3eb Simplification of API. 2025-01-04 23:12:54 +01:00
Niels Bross
7787d1307b More extension bike shedding. 2025-01-01 23:14:30 +01:00
Niels Bross
4deb07027f Fix some tests and do some cleanup. 2025-01-01 23:06:53 +01:00
Niels Bross
f13508262b Remove dumbass type constraint crap. 2024-12-29 23:39:57 +01:00
74 changed files with 558 additions and 698 deletions
Expand all files Collapse all files

40
Codegen.jai
View File

@@ -88,14 +88,14 @@ dx11_type_to_string :: (type_variable : Type_Variable) -> string {
emit_field :: (state : *Codegen_State, node : *AST_Node, indentation : int) { emit_field :: (state : *Codegen_State, node : *AST_Node, indentation : int) {
find_result := find_symbol(state.scope_stack, node.name, state.current_scope); find_result := find_symbol(state.scope_stack, node.name, state.current_scope);
field := h2tv(state.type_variables, find_result.type_variable); field := from_handle(state.type_variables, find_result.type_variable);
indent(state, indentation); indent(state, indentation);
print_to_builder(*state.builder, "% ", dx11_type_to_string(field)); print_to_builder(*state.builder, "% ", dx11_type_to_string(field));
if field.struct_field_parent { if field.struct_field_parent {
parent_tv := h2tv(state.type_variables, field.struct_field_parent.type_variable); parent_tv := from_handle(state.type_variables, field.struct_field_parent.type_variable);
if parent_tv.typename == "properties" { if parent_tv.typename == "properties" {
append(*state.builder, "__PROPERTIES__"); append(*state.builder, "__PROPERTIES__");
@@ -119,7 +119,7 @@ emit_field :: (state : *Codegen_State, node : *AST_Node, indentation : int) {
} }
for i :0..field.children.count - 1 { for i :0..field.children.count - 1 {
child := h2tv(state.type_variables, field.children[i]); child := from_handle(state.type_variables, field.children[i]);
emit_node(state, child.source_node, 0); emit_node(state, child.source_node, 0);
} }
@@ -198,7 +198,7 @@ emit_properties :: (state : *Codegen_State, node : *AST_Node, indentation : int)
} }
assert(find_result != null, "Attempting to generate undeclared properties buffer. This should never happen at this stage."); assert(find_result != null, "Attempting to generate undeclared properties buffer. This should never happen at this stage.");
variable := h2tv(state.type_variables, find_result.type_variable); variable := from_handle(state.type_variables, find_result.type_variable);
print_to_builder(*state.builder, "cbuffer __PROPERTIES : register(b%) \n{\n", variable.resource_index); print_to_builder(*state.builder, "cbuffer __PROPERTIES : register(b%) \n{\n", variable.resource_index);
@@ -210,7 +210,7 @@ emit_properties :: (state : *Codegen_State, node : *AST_Node, indentation : int)
for child : node.children { for child : node.children {
if child.kind == .FieldList { if child.kind == .FieldList {
for field : child.children { for field : child.children {
tv := h2tv(state.type_variables, field.type_variable); tv := from_handle(state.type_variables, field.type_variable);
if tv.type == .Sampler || tv.type == .Texture2D { if tv.type == .Sampler || tv.type == .Texture2D {
array_add(*resources, field); array_add(*resources, field);
continue; continue;
@@ -250,12 +250,12 @@ emit_function :: (state : *Codegen_State, node : *AST_Node, indentation : int, e
} }
for func : find_result.functions { for func : find_result.functions {
function_variable := h2tv(state.type_variables, func.type_variable); function_variable := from_handle(state.type_variables, func.type_variable);
indent(state, indentation); indent(state, indentation);
if function_variable.return_type_variable { if function_variable.return_type_variable {
return_variable := h2tv(state.type_variables, function_variable.return_type_variable); return_variable := from_handle(state.type_variables, function_variable.return_type_variable);
print_to_builder(*state.builder, "% ", dx11_type_to_string(return_variable)); print_to_builder(*state.builder, "% ", dx11_type_to_string(return_variable));
} else { } else {
append(*state.builder, "void "); append(*state.builder, "void ");
@@ -379,12 +379,12 @@ emit_node :: (state : *Codegen_State, node : *AST_Node, indentation : int) {
case .Variable; { case .Variable; {
indent(*state.builder, indentation); indent(*state.builder, indentation);
type_var := h2tv(state.type_variables, node.type_variable); type_var := from_handle(state.type_variables, node.type_variable);
is_properties := type_var.typename == "properties"; is_properties := type_var.typename == "properties";
if !is_properties { if !is_properties {
if type_var.struct_field_parent { if type_var.struct_field_parent {
parent_tv := h2tv(state.type_variables, type_var.struct_field_parent.type_variable); parent_tv := from_handle(state.type_variables, type_var.struct_field_parent.type_variable);
if parent_tv.typename == "properties" { if parent_tv.typename == "properties" {
append(*state.builder, "__PROPERTIES__"); append(*state.builder, "__PROPERTIES__");
@@ -450,7 +450,7 @@ emit_struct :: (state : *Codegen_State, node : *AST_Node, indentation : int) {
print_to_builder(*state.builder, "struct %", node.name); print_to_builder(*state.builder, "struct %", node.name);
current_scope := state.current_scope; current_scope := state.current_scope;
state.current_scope = h2tv(state.type_variables, node.type_variable).scope; state.current_scope = from_handle(state.type_variables, node.type_variable).scope;
field_list := node.children[0]; field_list := node.children[0];
@@ -467,11 +467,11 @@ emit_struct :: (state : *Codegen_State, node : *AST_Node, indentation : int) {
} }
emit_cbuffer :: (state : *Codegen_State, node : *AST_Node, indentation : int) { emit_cbuffer :: (state : *Codegen_State, node : *AST_Node, indentation : int) {
variable := h2tv(state.type_variables, node.type_variable); variable := from_handle(state.type_variables, node.type_variable);
print_to_builder(*state.builder, "cbuffer % : register(b%)", variable.name, variable.resource_index); print_to_builder(*state.builder, "cbuffer % : register(b%)", variable.name, variable.resource_index);
current_scope := state.current_scope; current_scope := state.current_scope;
state.current_scope = h2tv(state.type_variables, node.type_variable).scope; state.current_scope = from_handle(state.type_variables, node.type_variable).scope;
field_list := node.children[0]; field_list := node.children[0];
@@ -504,6 +504,22 @@ emit_declaration :: (state : *Codegen_State, node : *AST_Node) {
} }
} }
codegen :: (result : *Compile_Result) {
if result.had_error {
return;
}
for *file : result.files {
state : Codegen_State;
init_codegen_state(*state, file.ast_root, file.semantic_check_result, .HLSL);
//@Incomplete(nb): just call the codegen function for now with old result struct
codegen_result := codegen(*state);
file.codegen_result_text = copy_string(codegen_result.result_text);
}
}
codegen :: (state : *Codegen_State) -> Codegen_Result { codegen :: (state : *Codegen_State) -> Codegen_Result {
found_function : bool = false; found_function : bool = false;
// found_struct : bool = false; // found_struct : bool = false;

6
Lexing.jai
View File

@@ -506,14 +506,18 @@ lex :: (result : *Compile_Result) {
return; return;
} }
for file : result.files { for *file : result.files {
lexer : Lexer; lexer : Lexer;
init_lexer_from_string(*lexer, file.file.source); init_lexer_from_string(*lexer, file.file.source);
lexer.path = file.file.path;
token : *Token = scan_next_token(*lexer); token : *Token = scan_next_token(*lexer);
while token && token.kind != .TOKEN_EOF { while token && token.kind != .TOKEN_EOF {
token = scan_next_token(*lexer); token = scan_next_token(*lexer);
} }
array_copy(*file.tokens.tokens, lexer.result.tokens);
result.had_error |= lexer.result.had_error;
// @Incomplete(nb): Temporary until we figure out a good way of passing this stuff around // @Incomplete(nb): Temporary until we figure out a good way of passing this stuff around
copy_messages(lexer.result.messages, *result.messages); copy_messages(lexer.result.messages, *result.messages);
} }

5
Parsing.jai
View File

@@ -465,6 +465,7 @@ array_access :: (parse_state : *Parse_State, left : *AST_Node) -> *AST_Node {
} }
source_location.end = parse_state.previous; source_location.end = parse_state.previous;
left.source_location = source_location;
return left; return left;
} }
@@ -1060,6 +1061,10 @@ declaration :: (parse_state : *Parse_State) -> *AST_Node {
} }
parse :: (result : *Compile_Result) { parse :: (result : *Compile_Result) {
if result.had_error {
return;
}
for *file : result.files { for *file : result.files {
parse_state : Parse_State; parse_state : Parse_State;
init_parse_state(*parse_state, file.tokens.tokens, file.file.path); init_parse_state(*parse_state, file.tokens.tokens, file.file.path);

486
Semantic_Analysis.jai
View File

@@ -77,52 +77,10 @@ Type_Variable :: struct {
//@Note(niels): For constant buffers //@Note(niels): For constant buffers
resource_index : u32; resource_index : u32;
uf_parent : Type_Variable_Handle;
source_node : *AST_Node; source_node : *AST_Node;
} }
Type_Variable_Handle :: #type, distinct u32; Type_Variable_Handle :: #type, distinct u32;
Type_Constraint_Handle :: #type, distinct u32;
Type_Constraint_Kind :: enum {
Int_Literal; // [[I]] = int
Float_Literal; // [[F]] = float
Equivalence; // [[X]] = int/float
Equality; // E1 == E2: [[E1]] = [[E2]] && [[E1 == E2]] = bool
Function_Decl; // X(X1, ..., Xn) { return E; }: [[X]] = ([[X1]], ..., [[Xn]]) -> [[E]]
Function_Call; // E(E1, ..., En): [[E]] = ([[E1]], ..., [[En]]) -> [[E(E1, ..., En)]]
}
Type_Constraint :: struct {
kind : Type_Constraint_Kind;
union {
literal : struct {
type_variable : Type_Variable_Handle;
union {
i : int;
f : float;
}
}
equivalence : struct {
lhs : Type_Variable_Handle;
rhs : Type_Variable_Handle;
}
function : struct {
symbol_variable : Type_Variable_Handle;
return_variable : Type_Variable_Handle;
arguments : [16]Type_Variable_Handle;
argument_count : int;
}
}
usage_site : *AST_Node;
binary_operator : Token;
}
Scope_Stack :: struct { Scope_Stack :: struct {
allocator : Allocator; allocator : Allocator;
@@ -199,7 +157,6 @@ Semantic_Checker :: struct {
current_scope : Scope_Handle; current_scope : Scope_Handle;
// type_variables : [..]Type_Variable; // type_variables : [..]Type_Variable;
constraints : [..]Type_Constraint;
current_buffer_index : u32 = 0; current_buffer_index : u32 = 0;
current_sampler_index : u32 = 0; current_sampler_index : u32 = 0;
@@ -342,7 +299,7 @@ no_matching_overload_found :: (checker : *Semantic_Checker, call : *AST_Node, ov
append(*builder, "Possible overloads:\n"); append(*builder, "Possible overloads:\n");
for func : overloads.functions { for func : overloads.functions {
func_var := h2tv(checker, func.type_variable); func_var := from_handle(checker, func.type_variable);
cyan(*builder); cyan(*builder);
// foo :: (f : float) {} (file_path:line_num) // foo :: (f : float) {} (file_path:line_num)
@@ -359,7 +316,7 @@ no_matching_overload_found :: (checker : *Semantic_Checker, call : *AST_Node, ov
arg_list := call.children[0]; arg_list := call.children[0];
indent(*builder, 2); indent(*builder, 2);
func_var := h2tv(checker, func.type_variable); func_var := from_handle(checker, func.type_variable);
if arg_list.children.count != func_var.children.count { if arg_list.children.count != func_var.children.count {
print_to_builder(*builder, "Not enough arguments: Wanted %, got %.\n\n", func_var.children.count, arg_list.children.count); print_to_builder(*builder, "Not enough arguments: Wanted %, got %.\n\n", func_var.children.count, arg_list.children.count);
@@ -505,7 +462,7 @@ Attempting to access a field on a primitive type '%'.
builder : String_Builder; builder : String_Builder;
init_string_builder(*builder,, temp); init_string_builder(*builder,, temp);
variable := h2tv(checker, handle); variable := from_handle(checker, handle);
print_to_builder(*builder, "Attempting to access a field on a primitive type '%'.\n", proper_type_to_string(checker, variable)); print_to_builder(*builder, "Attempting to access a field on a primitive type '%'.\n", proper_type_to_string(checker, variable));
indent(*builder, 1); indent(*builder, 1);
@@ -513,7 +470,7 @@ Attempting to access a field on a primitive type '%'.
print_to_builder(*builder, "%\n", print_from_source_location(node.source_location)); print_to_builder(*builder, "%\n", print_from_source_location(node.source_location));
indent(*builder, 1); indent(*builder, 1);
node_variable := h2tv(checker, node.type_variable); node_variable := from_handle(checker, node.type_variable);
for 0..node.name.count - 1 { for 0..node.name.count - 1 {
append(*builder, " "); append(*builder, " ");
@@ -533,8 +490,8 @@ Attempting to access a field on a primitive type '%'.
} }
type_mismatch :: (checker : *Semantic_Checker, usage_site : *AST_Node, expect_node : *AST_Node, expect : Type_Variable_Handle, got : Type_Variable_Handle) { type_mismatch :: (checker : *Semantic_Checker, usage_site : *AST_Node, expect_node : *AST_Node, expect : Type_Variable_Handle, got : Type_Variable_Handle) {
expect_var := h2tv(checker, expect); expect_var := from_handle(checker, expect);
got_var := h2tv(checker, got); got_var := from_handle(checker, got);
builder : String_Builder; builder : String_Builder;
init_string_builder(*builder,, temp); init_string_builder(*builder,, temp);
@@ -544,7 +501,7 @@ type_mismatch :: (checker : *Semantic_Checker, usage_site : *AST_Node, expect_no
for i: 0..got_var.children.count - 1{ for i: 0..got_var.children.count - 1{
child_handle := got_var.children[i]; child_handle := got_var.children[i];
child := h2tv(checker, child_handle); child := from_handle(checker, child_handle);
print_to_builder(*builder, "% : %", child.name, type_to_string(child)); print_to_builder(*builder, "% : %", child.name, type_to_string(child));
} }
@@ -708,10 +665,9 @@ add_symbol_to_scope :: (checker : *Semantic_Checker, scope_handle : Scope_Handle
new_type_variable :: (checker : *Semantic_Checker) -> *Type_Variable, Type_Variable_Handle { new_type_variable :: (checker : *Semantic_Checker) -> *Type_Variable, Type_Variable_Handle {
variable : Type_Variable; variable : Type_Variable;
handle := cast(Type_Variable_Handle)checker.result.type_variables.count + 1; handle := cast(Type_Variable_Handle)checker.result.type_variables.count + 1;
variable.uf_parent = handle;
array_add(*checker.result.type_variables, variable); array_add(*checker.result.type_variables, variable);
return h2tv(checker, handle), handle; return from_handle(checker, handle), handle;
} }
add_child :: (variable : *Type_Variable, child : Type_Variable_Handle) { add_child :: (variable : *Type_Variable, child : Type_Variable_Handle) {
@@ -722,12 +678,18 @@ add_child :: (variable : *Type_Variable, child : Type_Variable_Handle) {
} }
add_child :: (checker : *Semantic_Checker, handle : Type_Variable_Handle, child : Type_Variable_Handle) { add_child :: (checker : *Semantic_Checker, handle : Type_Variable_Handle, child : Type_Variable_Handle) {
variable := h2tv(checker, handle); variable := from_handle(checker, handle);
assert(variable.children.count < Type_Variable.MAX_TYPE_VARIABLE_CHILDREN); assert(variable.children.count < Type_Variable.MAX_TYPE_VARIABLE_CHILDREN);
array_add(*variable.children, child); array_add(*variable.children, child);
} }
init_semantic_checker :: (checker : *Semantic_Checker, root : *AST_Node, path : string) { init_semantic_checker :: (checker : *Semantic_Checker, root : *AST_Node, path : string) {
checker.current_buffer_index = 0;
checker.current_sampler_index = 0;
checker.current_texture_index = 0;
array_reserve(*checker.result.messages, 16);
checker.program_root = root; checker.program_root = root;
checker.path = path; checker.path = path;
@@ -769,13 +731,13 @@ find_symbol :: (name : string, checker : *Semantic_Checker, containing_scope : *
return find_symbol(checker, name, checker.current_scope, containing_scope); return find_symbol(checker, name, checker.current_scope, containing_scope);
} }
h2tv :: (variables : []Type_Variable, handle : Type_Variable_Handle) -> *Type_Variable { from_handle :: (variables : []Type_Variable, handle : Type_Variable_Handle) -> *Type_Variable {
assert(handle > 0 && xx handle <= variables.count, tprint("Invalid handle: %. Range is: 1-%", handle, variables.count - 1)); assert(handle > 0 && xx handle <= variables.count, tprint("Invalid handle: %. Range is: 1-%", handle, variables.count - 1));
return *variables[handle - 1]; return *variables[handle - 1];
} }
h2tv :: (checker : *Semantic_Checker, handle : Type_Variable_Handle) -> *Type_Variable { from_handle :: (checker : *Semantic_Checker, handle : Type_Variable_Handle) -> *Type_Variable {
return h2tv(checker.result.type_variables, handle); return from_handle(checker.result.type_variables, handle);
} }
proper_type_to_string :: (builder : *String_Builder, checker : *Semantic_Checker, var : Type_Variable) { proper_type_to_string :: (builder : *String_Builder, checker : *Semantic_Checker, var : Type_Variable) {
@@ -810,7 +772,7 @@ proper_type_to_string :: (builder : *String_Builder, checker : *Semantic_Checker
if var.return_type_variable > 0 { if var.return_type_variable > 0 {
append(builder, " -> ", ); append(builder, " -> ", );
return_var := h2tv(checker, var.return_type_variable); return_var := from_handle(checker, var.return_type_variable);
if is_proper(return_var) { if is_proper(return_var) {
proper_type_to_string(builder, checker, return_var); proper_type_to_string(builder, checker, return_var);
} else { } else {
@@ -866,7 +828,7 @@ get_type_from_identifier :: (checker : *Semantic_Checker, scope : Scope_Handle,
symbol := find_symbol(checker, type_string, scope); symbol := find_symbol(checker, type_string, scope);
if symbol { if symbol {
symbol_var := h2tv(checker, symbol.type_variable); symbol_var := from_handle(checker, symbol.type_variable);
if symbol_var.type == .Struct { if symbol_var.type == .Struct {
if typename { if typename {
typename.* = symbol_var.typename; typename.* = symbol_var.typename;
@@ -918,10 +880,10 @@ declare_struct :: (checker : *Semantic_Checker, node : *AST_Node, name : string)
for child : node.children { for child : node.children {
if child.kind == .FieldList { if child.kind == .FieldList {
for field : child.children { for field : child.children {
type_var := check_node(checker, field); type_var := create_field(checker, field);
if type_var > 0 { if type_var > 0 {
h2tv(checker, type_var).scope = scope_handle; from_handle(checker, type_var).scope = scope_handle;
add_child(checker, handle, type_var); add_child(checker, handle, type_var);
} }
} }
@@ -944,7 +906,7 @@ declare_properties :: (checker : *Semantic_Checker, node : *AST_Node) -> Type_Va
checker.result.property_name = name; checker.result.property_name = name;
} }
type_var := declare_struct(checker, node, name); type_var := declare_struct(checker, node, name);
var := h2tv(checker, type_var); var := from_handle(checker, type_var);
var.type = .Properties; var.type = .Properties;
var.typename = "properties"; var.typename = "properties";
var.resource_index = checker.current_buffer_index; var.resource_index = checker.current_buffer_index;
@@ -954,7 +916,7 @@ declare_properties :: (checker : *Semantic_Checker, node : *AST_Node) -> Type_Va
declare_cbuffer :: (checker : *Semantic_Checker, node : *AST_Node) -> Type_Variable_Handle { declare_cbuffer :: (checker : *Semantic_Checker, node : *AST_Node) -> Type_Variable_Handle {
type_var := declare_struct(checker, node); type_var := declare_struct(checker, node);
var := h2tv(checker, type_var); var := from_handle(checker, type_var);
var.type = .CBuffer; var.type = .CBuffer;
var.resource_index = checker.current_buffer_index; var.resource_index = checker.current_buffer_index;
checker.current_buffer_index += 1; checker.current_buffer_index += 1;
@@ -1021,7 +983,7 @@ declare_function :: (checker : *Semantic_Checker, node : *AST_Node, builtin : bo
field_list := node.children[0]; field_list := node.children[0];
for function : find_result.functions { for function : find_result.functions {
func_var := h2tv(checker, function.type_variable); func_var := from_handle(checker, function.type_variable);
if func_var.source_node.children[0].children.count != field_list.children.count { if func_var.source_node.children[0].children.count != field_list.children.count {
continue; continue;
} }
@@ -1033,7 +995,7 @@ declare_function :: (checker : *Semantic_Checker, node : *AST_Node, builtin : bo
typename : string; typename : string;
arg_type := get_type_from_identifier(checker, checker.current_scope, node_child, *typename); arg_type := get_type_from_identifier(checker, checker.current_scope, node_child, *typename);
other_arg := h2tv(checker, arg); other_arg := from_handle(checker, arg);
if arg_type != other_arg.type { if arg_type != other_arg.type {
all_same = false; all_same = false;
@@ -1081,7 +1043,7 @@ declare_function :: (checker : *Semantic_Checker, node : *AST_Node, builtin : bo
type_var := check_node(checker, field); type_var := check_node(checker, field);
if type_var > 0 { if type_var > 0 {
if builtin { if builtin {
var := h2tv(checker, type_var); var := from_handle(checker, type_var);
var.builtin = true; var.builtin = true;
} }
add_child(checker, handle, type_var); add_child(checker, handle, type_var);
@@ -1093,7 +1055,7 @@ declare_function :: (checker : *Semantic_Checker, node : *AST_Node, builtin : bo
if builtin && node.token.ident_value.count > 0 { if builtin && node.token.ident_value.count > 0 {
return_var, return_handle := new_type_variable(checker); return_var, return_handle := new_type_variable(checker);
return_var.type = get_type_from_identifier(checker, checker.current_scope, node, *return_var.typename); return_var.type = get_type_from_identifier(checker, checker.current_scope, node, *return_var.typename);
h2tv(checker, handle).return_type_variable= return_handle; from_handle(checker, handle).return_type_variable= return_handle;
} }
if !builtin { if !builtin {
@@ -1103,7 +1065,7 @@ declare_function :: (checker : *Semantic_Checker, node : *AST_Node, builtin : bo
return handle; return handle;
} }
create_function_constraint :: (checker : *Semantic_Checker, node : *AST_Node) { create_function :: (checker : *Semantic_Checker, node : *AST_Node) {
name_to_check := get_actual_function_name(node); name_to_check := get_actual_function_name(node);
find_result := find_symbol(checker, name_to_check, checker.current_scope); find_result := find_symbol(checker, name_to_check, checker.current_scope);
@@ -1117,38 +1079,24 @@ create_function_constraint :: (checker : *Semantic_Checker, node : *AST_Node) {
} }
for function : find_result.functions { for function : find_result.functions {
variable := h2tv(checker, function.type_variable); variable := from_handle(checker, function.type_variable);
assert(variable.scope > 0, "Declared function is missing scope."); assert(variable.scope > 0, "Declared function is missing scope.");
previous_scope := use_scope(checker, variable.scope); previous_scope := use_scope(checker, variable.scope);
constraint : Type_Constraint;
constraint.kind = .Function_Decl;
constraint.function.symbol_variable = function.type_variable;
for i : 0..variable.children.count - 1 {
arg_var := variable.children[i];
if arg_var > 0 {
constraint.function.arguments[constraint.function.argument_count] = arg_var;
constraint.function.argument_count += 1;
}
}
for child : node.children { for child : node.children {
if child.kind == .Block { if child.kind == .Block {
for statement : child.children { for statement : child.children {
if statement.kind == .Return { if statement.kind == .Return {
result_var := check_node(checker, statement); result_var := check_node(checker, statement);
if result_var > 0 { if result_var > 0 {
variable.return_type_variable= result_var; variable.return_type_variable = result_var;
constraint.function.return_variable = variable.return_type_variable;
} }
} else { } else {
result_var := check_node(checker, statement); result_var := check_node(checker, statement);
if result_var > 0 { if result_var > 0 {
stm := h2tv(checker, result_var); stm := from_handle(checker, result_var);
add_child(variable, result_var); add_child(variable, result_var);
} }
} }
@@ -1160,44 +1108,10 @@ create_function_constraint :: (checker : *Semantic_Checker, node : *AST_Node) {
not_all_control_paths_return_value(checker, node); not_all_control_paths_return_value(checker, node);
} }
array_add(*checker.constraints, constraint);
use_scope(checker, previous_scope); use_scope(checker, previous_scope);
} }
} }
create_literal_constraint :: (checker : *Semantic_Checker, value : int, type_variable : Type_Variable_Handle) {
constraint : Type_Constraint;
constraint.kind = .Int_Literal;
constraint.literal.i = value;
constraint.literal.type_variable = type_variable;
array_add(*checker.constraints, constraint);
}
create_literal_constraint :: (checker : *Semantic_Checker, value : float, type_variable : Type_Variable_Handle) -> Type_Constraint_Handle {
constraint : Type_Constraint;
constraint.kind = .Float_Literal;
constraint.literal.f = value;
constraint.literal.type_variable = type_variable;
array_add(*checker.constraints, constraint);
return cast(Type_Constraint_Handle)checker.constraints.count;
}
create_equivalence_constraint :: (checker : *Semantic_Checker, lhs : Type_Variable_Handle, rhs : Type_Variable_Handle, usage_site : *AST_Node = null) -> Type_Constraint_Handle {
constraint : Type_Constraint;
constraint.kind = .Equivalence;
constraint.equivalence.lhs = lhs;
constraint.equivalence.rhs = rhs;
constraint.usage_site = usage_site;
array_add(*checker.constraints, constraint);
return cast(Type_Constraint_Handle)checker.constraints.count;
}
create_variable :: (checker : *Semantic_Checker, node : *AST_Node, struct_field_parent : *AST_Node = null) -> Type_Variable_Handle { create_variable :: (checker : *Semantic_Checker, node : *AST_Node, struct_field_parent : *AST_Node = null) -> Type_Variable_Handle {
find_result := find_symbol(checker, node.name, checker.current_scope); find_result := find_symbol(checker, node.name, checker.current_scope);
// x : int; // x : int;
@@ -1205,7 +1119,7 @@ create_variable :: (checker : *Semantic_Checker, node : *AST_Node, struct_field_
if find_result { if find_result {
node.type_variable = find_result.type_variable; node.type_variable = find_result.type_variable;
variable := h2tv(checker, find_result.type_variable); variable := from_handle(checker, find_result.type_variable);
variable.struct_field_parent = struct_field_parent; variable.struct_field_parent = struct_field_parent;
if get_scope(checker, checker.current_scope).kind == .Struct { if get_scope(checker, checker.current_scope).kind == .Struct {
@@ -1222,7 +1136,7 @@ create_variable :: (checker : *Semantic_Checker, node : *AST_Node, struct_field_
lookup_name = variable.name; lookup_name = variable.name;
} }
struct_symbol := find_symbol(checker, lookup_name, checker.current_scope); struct_symbol := find_symbol(checker, lookup_name, checker.current_scope);
type_variable := h2tv(checker, struct_symbol.type_variable); type_variable := from_handle(checker, struct_symbol.type_variable);
previous_scope := use_scope(checker, type_variable.scope); previous_scope := use_scope(checker, type_variable.scope);
child := node.children[0]; child := node.children[0];
@@ -1267,7 +1181,7 @@ create_field :: (checker : *Semantic_Checker, node : *AST_Node) -> Type_Variable
if variable.is_array { if variable.is_array {
size_node := node.children[0]; size_node := node.children[0];
size_var := check_node(checker, size_node); size_var := check_node(checker, size_node);
if h2tv(checker, size_var).type != .Int { if from_handle(checker, size_var).type != .Int {
//@Incomplete(niels): Type mismatch here. With integral type required message. //@Incomplete(niels): Type mismatch here. With integral type required message.
} }
} }
@@ -1317,18 +1231,30 @@ create_field :: (checker : *Semantic_Checker, node : *AST_Node) -> Type_Variable
for child : node.children { for child : node.children {
rhs = check_node(checker, child); rhs = check_node(checker, child);
} }
create_equivalence_constraint(checker, handle, rhs, node);
if handle == 0 || rhs == 0 {
return handle;
}
l := from_handle(checker, handle);
r := from_handle(checker, rhs);
assert(l.type != .Unresolved_Expression && r.type != .Unresolved_Expression);
if !types_compatible(checker, handle, rhs) {
type_mismatch(checker, l.source_node, r.source_node, rhs, handle);
return 0;
}
} }
return handle; return handle;
} }
create_call_constraint :: (checker : *Semantic_Checker, node : *AST_Node, type_var : Type_Variable_Handle) { check_call :: (checker : *Semantic_Checker, node : *AST_Node, type_var : Type_Variable_Handle) -> error : bool {
find_result := find_symbol(checker, node.name, checker.current_scope); find_result := find_symbol(checker, node.name, checker.current_scope);
if !find_result { if !find_result {
function_undeclared(checker, node); function_undeclared(checker, node);
return; return true;
} }
overload_found := false; overload_found := false;
@@ -1359,7 +1285,7 @@ create_call_constraint :: (checker : *Semantic_Checker, node : *AST_Node, type_v
} }
if arg_vars.count != arg_count { if arg_vars.count != arg_count {
return; return true;
} }
Type_Mismatch_Data :: struct { Type_Mismatch_Data :: struct {
@@ -1375,7 +1301,7 @@ create_call_constraint :: (checker : *Semantic_Checker, node : *AST_Node, type_v
break; break;
} }
function := h2tv(checker, func.type_variable); function := from_handle(checker, func.type_variable);
if arg_count != function.children.count { if arg_count != function.children.count {
continue; continue;
@@ -1383,6 +1309,9 @@ create_call_constraint :: (checker : *Semantic_Checker, node : *AST_Node, type_v
if node.children.count == 0 && function.children.count == 0 { if node.children.count == 0 && function.children.count == 0 {
overload_found = true; overload_found = true;
}
if overload_found && function.return_type_variable == 0 {
break; break;
} }
@@ -1395,7 +1324,7 @@ create_call_constraint :: (checker : *Semantic_Checker, node : *AST_Node, type_v
if all_args_match { if all_args_match {
arg_node = arg.node; arg_node = arg.node;
} }
fun_param := h2tv(checker, function_param); fun_param := from_handle(checker, function_param);
mismatch : Type_Mismatch_Data; mismatch : Type_Mismatch_Data;
mismatch.lhs = arg; mismatch.lhs = arg;
mismatch.rhs = .{ function_param, fun_param.source_node }; mismatch.rhs = .{ function_param, fun_param.source_node };
@@ -1409,9 +1338,9 @@ create_call_constraint :: (checker : *Semantic_Checker, node : *AST_Node, type_v
} }
if overload_found { if overload_found {
if function.return_type_variable> 0 { if function.return_type_variable > 0 {
return_var := h2tv(checker, function.return_type_variable); return_var := from_handle(checker, function.return_type_variable);
constrained_var := h2tv(checker, type_var); constrained_var := from_handle(checker, type_var);
constrained_var.type = return_var.type; constrained_var.type = return_var.type;
constrained_var.typename = return_var.typename; constrained_var.typename = return_var.typename;
} }
@@ -1424,13 +1353,17 @@ create_call_constraint :: (checker : *Semantic_Checker, node : *AST_Node, type_v
for mismatch : mismatches { for mismatch : mismatches {
type_mismatch(checker, mismatch.lhs.node, mismatch.rhs.node, mismatch.rhs.var, mismatch.lhs.var); type_mismatch(checker, mismatch.lhs.node, mismatch.rhs.node, mismatch.rhs.var, mismatch.lhs.var);
} }
return true;
} }
return false;
} }
check_node :: (checker : *Semantic_Checker, node : *AST_Node) -> Type_Variable_Handle { check_node :: (checker : *Semantic_Checker, node : *AST_Node) -> Type_Variable_Handle {
if node.kind == { if node.kind == {
case .Function; { case .Function; {
create_function_constraint(checker, node); create_function(checker, node);
return 0; return 0;
} }
case. Field; { case. Field; {
@@ -1452,7 +1385,7 @@ check_node :: (checker : *Semantic_Checker, node : *AST_Node) -> Type_Variable_H
} }
variable, handle := new_type_variable(checker); variable, handle := new_type_variable(checker);
lhs_type := h2tv(checker, lhs_var); lhs_type := from_handle(checker, lhs_var);
variable.type = lhs_type.type; variable.type = lhs_type.type;
variable.typename = lhs_type.typename; variable.typename = lhs_type.typename;
variable.scope = lhs_type.scope; variable.scope = lhs_type.scope;
@@ -1466,19 +1399,17 @@ check_node :: (checker : *Semantic_Checker, node : *AST_Node) -> Type_Variable_H
case .TOKEN_MINUS; #through; case .TOKEN_MINUS; #through;
case .TOKEN_STAR; #through; case .TOKEN_STAR; #through;
case .TOKEN_SLASH; { case .TOKEN_SLASH; {
create_equivalence_constraint(checker, rhs_var, lhs_var, node); if !types_compatible(checker, lhs_var, rhs_var, true) {
type_mismatch(checker, node, node.children[1], lhs_var, rhs_var);
proper_variable, rhs_handle := new_type_variable(checker); return 0;
lhs_type_var := h2tv(checker, lhs_var); }
proper_variable.type = lhs_type_var.type;
proper_variable.typename = lhs_type_var.typename;
proper_variable.source_node = h2tv(checker, lhs_var).source_node;
proper_variable.struct_field_parent = h2tv(checker, lhs_var).struct_field_parent;
create_equivalence_constraint(checker, handle, rhs_handle, node);
} }
case .TOKEN_ASSIGN; { case .TOKEN_ASSIGN; {
create_equivalence_constraint(checker, lhs_var, rhs_var, node);
if !types_compatible(checker, lhs_var, rhs_var, true) {
type_mismatch(checker, node.parent, node.children[1], lhs_var, rhs_var);
return 0;
}
} }
} }
return handle; return handle;
@@ -1494,7 +1425,6 @@ check_node :: (checker : *Semantic_Checker, node : *AST_Node) -> Type_Variable_H
type_variable.type = .Int; type_variable.type = .Int;
type_variable.source_node = node; type_variable.source_node = node;
node.type_variable = handle; node.type_variable = handle;
type_constraint := create_literal_constraint(checker, node.integer_value, handle);
return handle; return handle;
} }
@@ -1503,7 +1433,6 @@ check_node :: (checker : *Semantic_Checker, node : *AST_Node) -> Type_Variable_H
type_variable.type = .Float; type_variable.type = .Float;
type_variable.source_node = node; type_variable.source_node = node;
node.type_variable = handle; node.type_variable = handle;
type_constraint := create_literal_constraint(checker, node.float_value, handle);
return handle; return handle;
} }
@@ -1516,7 +1445,9 @@ check_node :: (checker : *Semantic_Checker, node : *AST_Node) -> Type_Variable_H
type_variable.source_node = node; type_variable.source_node = node;
node.type_variable = handle; node.type_variable = handle;
create_call_constraint(checker, node, handle); if check_call(checker, node, handle) {
return 0;
}
return handle; return handle;
} }
@@ -1555,16 +1486,16 @@ traverse :: (checker : *Semantic_Checker) {
traverse(checker, checker.program_root); traverse(checker, checker.program_root);
} }
find :: (checker : *Semantic_Checker, root_handle : Type_Variable_Handle) -> Type_Variable_Handle { // find :: (checker : *Semantic_Checker, root_handle : Type_Variable_Handle) -> Type_Variable_Handle {
assert(root_handle > 0); // assert(root_handle > 0);
root := h2tv(checker, root_handle); // root := from_handle(checker, root_handle);
if root.uf_parent != root_handle { // // if root.uf_parent != root_handle {
root.uf_parent = find(checker, root.uf_parent); // // root.uf_parent = find(checker, root.uf_parent);
} // // }
return root.uf_parent; // return root.uf_parent;
} // }
Unification_Result :: enum { Unification_Result :: enum {
Unification_Success; Unification_Success;
@@ -1572,8 +1503,8 @@ Unification_Result :: enum {
} }
types_compatible :: (checker : *Semantic_Checker, lhs : Type_Variable_Handle, rhs : Type_Variable_Handle, param_matching : bool = false) -> bool { types_compatible :: (checker : *Semantic_Checker, lhs : Type_Variable_Handle, rhs : Type_Variable_Handle, param_matching : bool = false) -> bool {
lhs_var := h2tv(checker, lhs); lhs_var := from_handle(checker, lhs);
rhs_var := h2tv(checker, rhs); rhs_var := from_handle(checker, rhs);
if lhs_var.type == { if lhs_var.type == {
case .Int; #through; case .Int; #through;
@@ -1627,8 +1558,8 @@ types_compatible :: (checker : *Semantic_Checker, lhs : Type_Variable_Handle, rh
return false; return false;
} }
lhs_struct_var := h2tv(checker, lhs_struct.type_variable); lhs_struct_var := from_handle(checker, lhs_struct.type_variable);
rhs_struct_var := h2tv(checker, rhs_struct.type_variable); rhs_struct_var := from_handle(checker, rhs_struct.type_variable);
if lhs_struct_var.children.count != rhs_struct_var.children.count { if lhs_struct_var.children.count != rhs_struct_var.children.count {
return false; return false;
@@ -1653,78 +1584,6 @@ types_compatible :: (checker : *Semantic_Checker, lhs : Type_Variable_Handle, rh
return false; return false;
} }
union_terms :: (checker : *Semantic_Checker, lhs_handle : Type_Variable_Handle, rhs_handle : Type_Variable_Handle, usage_site : *AST_Node) {
if !types_compatible(checker, lhs_handle, rhs_handle) {
lhs_var := h2tv(checker, lhs_handle);
rhs_var := h2tv(checker, rhs_handle);
if usage_site {
type_mismatch(checker, usage_site, rhs_var.source_node.parent, rhs_handle, lhs_handle);
} else {
type_mismatch(checker, lhs_var.source_node.parent, rhs_var.source_node.parent, rhs_handle, lhs_handle);
}
} else if lhs_handle != rhs_handle {
lhs := h2tv(checker, lhs_handle);
lhs.uf_parent = rhs_handle;
}
}
unify :: (checker : *Semantic_Checker, lhs_handle : Type_Variable_Handle, rhs_handle : Type_Variable_Handle, usage_site : *AST_Node = null) -> Unification_Result {
rep_lhs := find(checker, lhs_handle);
rep_rhs := find(checker, rhs_handle);
if rep_lhs != rep_rhs {
lhs := h2tv(checker, rep_lhs);
rhs := h2tv(checker, rep_rhs);
if !is_proper(lhs) && !is_proper(rhs) {
union_terms(checker, rep_lhs, rep_rhs, usage_site);
} else if !is_proper(lhs) && is_proper(rhs) {
union_terms(checker, rep_lhs, rep_rhs, usage_site);
} else if is_proper(lhs) && !is_proper(rhs) {
union_terms(checker, rep_rhs, rep_lhs, usage_site);
} else if is_proper(lhs) && is_proper(rhs) {
union_terms(checker, rep_lhs, rep_rhs, usage_site);
//@Incomplete(niels): Evaluate sub-terms for functions.
} else {
return .Unification_Failure;
}
}
return .Unification_Success;
}
union_find :: (checker : *Semantic_Checker) -> bool {
for constraint : checker.constraints {
if constraint.kind == {
case .Int_Literal; {
}
case .Float_Literal; {
}
case .Equivalence; {
if !constraint.equivalence.lhs || !constraint.equivalence.rhs {
return false;
}
handle_lhs := find(checker, constraint.equivalence.lhs);
handle_rhs := find(checker, constraint.equivalence.rhs);
unification_result := unify(checker, handle_lhs, handle_rhs, constraint.usage_site);
if unification_result == .Unification_Failure {
return false;
}
}
case .Function_Decl; {
}
}
}
return true;
}
// HLSL_BUILTIN :: #run -> string { // HLSL_BUILTIN :: #run -> string {
// T := #load "hlsl_builtin.jai"; // T := #load "hlsl_builtin.jai";
@@ -1796,23 +1655,29 @@ add_hlsl_builtins :: (checker : *Semantic_Checker) {
type_check :: (checker : *Semantic_Checker, root : *AST_Node) { type_check :: (checker : *Semantic_Checker, root : *AST_Node) {
traverse(checker, root); traverse(checker, root);
}
// if checker.result.had_error { check :: (result : *Compile_Result) {
// //@Incomplete(niels): handle error... if result.had_error {
// return checker.result; return;
// }
uf_result := union_find(checker);
if !uf_result {
//@Incomplete(niels): handle error...
// return result;
} }
for *type_variable : checker.result.type_variables { for *file : result.files {
if type_variable.type == .Unresolved_Variable { checker : Semantic_Checker;
rep := h2tv(checker, type_variable.uf_parent);
type_variable.type = rep.type; checker.current_buffer_index = 0;
} checker.current_sampler_index = 0;
checker.current_texture_index = 0;
array_reserve(*checker.result.messages, 16);
init_semantic_checker(*checker, file.ast_root, file.file.path);
add_hlsl_builtins(*checker);
type_check(*checker, file.ast_root);
file.semantic_check_result = checker.result;
copy_messages(checker.result.messages, *result.messages);
} }
} }
@@ -1821,7 +1686,6 @@ check :: (checker : *Semantic_Checker, root : *AST_Node) -> Semantic_Check_Resul
checker.current_sampler_index = 0; checker.current_sampler_index = 0;
checker.current_texture_index = 0; checker.current_texture_index = 0;
array_reserve(*checker.result.messages, 16); array_reserve(*checker.result.messages, 16);
array_reserve(*checker.constraints, 1024);
add_hlsl_builtins(checker); add_hlsl_builtins(checker);
type_check(checker, root); type_check(checker, root);
@@ -1886,7 +1750,7 @@ pretty_print_function :: (checker : *Semantic_Checker, builder : *String_Builder
for child : function.source_node.children { for child : function.source_node.children {
if child.kind == .FieldList { if child.kind == .FieldList {
for field : child.children { for field : child.children {
tv := h2tv(checker, field.type_variable); tv := from_handle(checker, field.type_variable);
if tv.type != .Function { if tv.type != .Function {
if tv.builtin { if tv.builtin {
print_to_builder(builder, "%", tv.name); print_to_builder(builder, "%", tv.name);
@@ -1905,7 +1769,7 @@ pretty_print_function :: (checker : *Semantic_Checker, builder : *String_Builder
} }
if function.return_type_variable> 0 { if function.return_type_variable> 0 {
print_to_builder(builder, ") -> %\n", type_to_string(h2tv(checker, function.return_type_variable))); print_to_builder(builder, ") -> %\n", type_to_string(from_handle(checker, function.return_type_variable)));
} else { } else {
append(builder, ")\n"); append(builder, ")\n");
} }
@@ -1918,7 +1782,7 @@ pretty_print_struct :: (checker : *Semantic_Checker, builder : *String_Builder,
for 0..struct_type.children.count - 1 { for 0..struct_type.children.count - 1 {
child_handle := struct_type.children[it]; child_handle := struct_type.children[it];
child := h2tv(checker, child_handle); child := from_handle(checker, child_handle);
print_to_builder(builder, child.name); print_to_builder(builder, child.name);
append(builder, " : "); append(builder, " : ");
print_to_builder(builder, type_to_string(child)); print_to_builder(builder, type_to_string(child));
@@ -1956,7 +1820,7 @@ pretty_print_scope :: (checker : *Semantic_Checker, scope : *Scope, builder : *S
if value.functions.count > 0 { if value.functions.count > 0 {
for func : value.functions { for func : value.functions {
type_variable := h2tv(checker, func.type_variable); type_variable := from_handle(checker, func.type_variable);
if type_variable.type == { if type_variable.type == {
case .Function; { case .Function; {
pretty_print_function(checker, builder, key, type_variable, 1); pretty_print_function(checker, builder, key, type_variable, 1);
@@ -1982,7 +1846,7 @@ pretty_print_scope :: (checker : *Semantic_Checker, scope : *Scope, builder : *S
} }
} }
} else { } else {
type_variable := h2tv(checker, value.type_variable); type_variable := from_handle(checker, value.type_variable);
if type_variable.type == { if type_variable.type == {
case .Function; { case .Function; {
pretty_print_function(checker, builder, key, type_variable, 1); pretty_print_function(checker, builder, key, type_variable, 1);
@@ -2019,64 +1883,6 @@ pretty_print_scope :: (checker : *Semantic_Checker, scope : *Scope, builder : *S
append(builder, "]\n"); append(builder, "]\n");
} }
pretty_print_constraint :: (checker : *Semantic_Checker, constraint : Type_Constraint, builder : *String_Builder) {
if constraint.kind == {
case .Int_Literal; {
print_to_builder(builder, "[[%]] = int\n", constraint.literal.i);
}
case .Float_Literal; {
print_to_builder(builder, "[[%]] = float\n", constraint.literal.f);
}
case .Equivalence; {
lhs_var := h2tv(checker, constraint.equivalence.lhs);
rhs_var := h2tv(checker, constraint.equivalence.rhs);
append(builder, "[[");
print_type_variable(builder, lhs_var, checker);
append(builder, "]] = ");
if rhs_var.source_node {
append(builder, "[[");
}
print_type_variable(builder, rhs_var, checker);
if rhs_var.source_node {
append(builder, "]]");
}
append(builder, "\n");
}
case .Function_Decl; {
sym := h2tv(checker, constraint.function.symbol_variable);
print_to_builder(builder, "[[%]] =", sym.name);
append(builder, " (");
if constraint.function.argument_count > 0 {
for i : 0..constraint.function.argument_count - 1 {
arg := h2tv(checker, constraint.function.arguments[i]);
print_to_builder(builder, "[[%]]", arg.name);
if i < constraint.function.argument_count - 1 {
append(builder, ", ");
}
}
}
append(builder, ")");
if constraint.function.return_variable > 0 {
return_var := h2tv(checker, constraint.function.return_variable);
append(builder, " -> ");
append(builder, "[[");
print_type_variable(builder, return_var, checker);
append(builder, "]]", );
append(builder, "\n");
} else {
append(builder, " -> unit\n");
}
}
}
}
print_type_variable :: (builder : *String_Builder, variable : Type_Variable, checker : *Semantic_Checker) { print_type_variable :: (builder : *String_Builder, variable : Type_Variable, checker : *Semantic_Checker) {
if variable.builtin { if variable.builtin {
if variable.type != .Function || variable.type != .Struct { if variable.type != .Function || variable.type != .Struct {
@@ -2160,7 +1966,7 @@ print_type_variable :: (builder : *String_Builder, variable : Type_Variable, che
} }
print_type_variable :: (builder : *String_Builder, checker : *Semantic_Checker, handle : Type_Variable_Handle) { print_type_variable :: (builder : *String_Builder, checker : *Semantic_Checker, handle : Type_Variable_Handle) {
variable := h2tv(checker, handle); variable := from_handle(checker, handle);
print_type_variable(builder, variable, checker); print_type_variable(builder, variable, checker);
} }
@@ -2173,68 +1979,6 @@ pretty_print_symbol_table :: (checker : *Semantic_Checker, allocator : Allocator
return builder_to_string(*builder,, allocator); return builder_to_string(*builder,, allocator);
} }
pretty_print_type_variable :: (checker : *Semantic_Checker, type_variable : *Type_Variable, builder : *String_Builder) {
rep := type_variable.uf_parent;
if type_variable.name.count > 0 {
append(builder, "[[");
print_type_variable(builder, type_variable, checker);
append(builder, "]] = ");
rep_var := h2tv(checker, rep);
if is_proper(type_variable) {
print_to_builder(builder, proper_type_to_string(checker, type_variable, temp));
} else if type_variable.type == .Struct || type_variable.type == .Properties ||
type_variable.type == .CBuffer {
if type_variable.kind == .Declaration {
append(builder, "{");
for 0..type_variable.children.count - 1 {
child_handle := type_variable.children[it];
child := h2tv(checker, child_handle);
print_to_builder(builder, child.name);
append(builder, " : ");
print_to_builder(builder, type_to_string(child));
if it < type_variable.children.count - 1 {
append(builder, ", ");
}
}
append(builder, "}");
} else if type_variable.typename.count > 0 {
print_to_builder(builder, "%", type_variable.typename);
}
} else {
print_from_source_location(builder, rep_var.source_node.source_location);
}
append(builder, "\n");
}
}
pretty_print_type_variables :: (checker : *Semantic_Checker, allocator : Allocator) -> string {
builder : String_Builder;
init_string_builder(*builder,, allocator);
for *type_variable : checker.result.type_variables {
if type_variable.builtin continue;
pretty_print_type_variable(checker, type_variable, *builder);
}
return builder_to_string(*builder,, allocator);
}
pretty_print_type_constraints :: (checker : *Semantic_Checker, allocator : Allocator) -> string {
builder : String_Builder;
init_string_builder(*builder,, allocator);
for *constraint : checker.constraints {
pretty_print_constraint(checker, constraint, *builder);
}
return builder_to_string(*builder,, allocator);
}
#scope_module #scope_module
#import "ncore"; #import "ncore";

26
Test.jai
View File

@@ -21,7 +21,7 @@ COMPILED_FOLDER :: "compiled";
SEMANTIC_ANALYSIS_FOLDER :: "semant"; SEMANTIC_ANALYSIS_FOLDER :: "semant";
TESTS_FOLDER :: "test"; TESTS_FOLDER :: "test";
SHADER_EXTENSION :: "shd"; SHADER_EXTENSION :: "ink";
SUITE_EXTENSION :: "suite"; SUITE_EXTENSION :: "suite";
Stage_Flags :: enum_flags u16 { Stage_Flags :: enum_flags u16 {
@@ -308,10 +308,6 @@ run_semantic_analysis_test :: (file_path : string, root : *AST_Node, output_type
result_text = report_messages(checker.result.messages); result_text = report_messages(checker.result.messages);
} else { } else {
result_text = pretty_print_symbol_table(*checker, temp); result_text = pretty_print_symbol_table(*checker, temp);
constraints := pretty_print_type_constraints(*checker, temp);
type_vars := pretty_print_type_variables(*checker, temp);
// print("Constraints\n%\n", constraints);
// print("Solution\n%\n", type_vars);
} }
if output_type & .StdOut { if output_type & .StdOut {
@@ -415,6 +411,8 @@ run_compile_test :: (path : string, output_type : Output_Type = 0) -> Result, Co
compiler : Shader_Compiler; compiler : Shader_Compiler;
result : Result; result : Result;
compilation_result := compile_file(*compiler, path); compilation_result := compile_file(*compiler, path);
print("\n");
if compilation_result.had_error { if compilation_result.had_error {
result.type = .Failed; result.type = .Failed;
result.info_text = tprint("Failed compiling: %\n", path); result.info_text = tprint("Failed compiling: %\n", path);
@@ -588,8 +586,11 @@ read_suite :: (file_path : string, suite : *Test_Suite) -> bool {
} }
if line.count == 1 { if line.count == 1 {
log_error("Invalid line - % - %\n", it_index + 1, line); line = split(split_line, "\t");
continue; if line.count == 1 {
log_error("Invalid line - % - \n", it_index + 1);
continue;
}
} }
test_case_path := line[0]; test_case_path := line[0];
stage_flags : Stage_Flags; stage_flags : Stage_Flags;
@@ -608,7 +609,6 @@ read_suite :: (file_path : string, suite : *Test_Suite) -> bool {
stage_flags |= .Compile; stage_flags |= .Compile;
} }
} }
test_case := make_test_case(test_case_path, stage_flags); test_case := make_test_case(test_case_path, stage_flags);
array_add(*suite.test_cases, test_case); array_add(*suite.test_cases, test_case);
} }
@@ -705,7 +705,7 @@ main :: () {
} else if arg == "-output" { } else if arg == "-output" {
output_type |= .StdOut; output_type |= .StdOut;
} else { } else {
print("%Unknown argument %\n", red(), arg); print("%Unknown argument % %\n", red(), arg, reset_color());
} }
} }
case .Run_Test; { case .Run_Test; {
@@ -727,9 +727,11 @@ main :: () {
path := copy_string(arg); path := copy_string(arg);
test_case := make_test_case(path, 0); test_case := make_test_case(path, 0);
array_add(*current_suite.test_cases, test_case); array_add(*current_suite.test_cases, test_case);
} else {
print("%Invalid file as argument % %\n", red(), arg, reset_color());
} }
} else { } else {
print("%Unknown argument %\n", red, arg); print("%Unknown argument % %\n", red(), arg, reset_color());
} }
} }
case .None; { case .None; {
@@ -748,7 +750,6 @@ main :: () {
array_add(*suites, suite); array_add(*suites, suite);
current_suite = *suites[0]; current_suite = *suites[0];
} }
arg_parse_state = .Run_Test; arg_parse_state = .Run_Test;
path := copy_string(arg); path := copy_string(arg);
test_case := make_test_case(path, 0); test_case := make_test_case(path, 0);
@@ -758,7 +759,6 @@ main :: () {
log_error("Unable to run a suite while already running test."); log_error("Unable to run a suite while already running test.");
continue; continue;
} }
arg_parse_state = .Run_Suite; arg_parse_state = .Run_Suite;
path := copy_string(arg); path := copy_string(arg);
@@ -766,6 +766,8 @@ main :: () {
read_suite(path, *suite); read_suite(path, *suite);
array_add(*suites, suite); array_add(*suites, suite);
current_suite = *suites[0]; current_suite = *suites[0];
} else {
print("%Invalid file as argument % %\n", red(), arg, reset_color());
} }
} }
} }

3
check.bat Normal file
View File

@@ -0,0 +1,3 @@
@echo off
jai first.jai -natvis - check

10
first.jai
View File

@@ -16,6 +16,16 @@ build :: () {
options.write_added_strings = true; options.write_added_strings = true;
args := options.compile_time_command_line;
for arg : args {
if arg == {
case "check"; {
options.output_type = .NO_OUTPUT;
}
}
}
new_path: [..] string; new_path: [..] string;
array_add(*new_path, ..options.import_path); array_add(*new_path, ..options.import_path);
array_add(*new_path, "modules"); array_add(*new_path, "modules");

30
module.jai
View File

@@ -146,6 +146,10 @@ Compiled_File :: struct {
tokens : Token_Stream; tokens : Token_Stream;
ast_root : *AST_Node; ast_root : *AST_Node;
ast_nodes : [..]AST_Node; ast_nodes : [..]AST_Node;
codegen_result_text : string;
semantic_check_result : Semantic_Check_Result;
} }
Compile_Result :: struct { Compile_Result :: struct {
@@ -279,7 +283,7 @@ pretty_print_field :: (builder : *String_Builder, field : *Field) {
} }
type_variable_to_field :: (checker : *Semantic_Checker, variable : Type_Variable_Handle) -> Field { type_variable_to_field :: (checker : *Semantic_Checker, variable : Type_Variable_Handle) -> Field {
return type_variable_to_field(checker, h2tv(checker, variable)); return type_variable_to_field(checker, from_handle(checker, variable));
} }
type_variable_to_field :: (checker : *Semantic_Checker, variable : *Type_Variable) -> Field { type_variable_to_field :: (checker : *Semantic_Checker, variable : *Type_Variable) -> Field {
@@ -318,11 +322,11 @@ type_variable_to_field :: (checker : *Semantic_Checker, variable : *Type_Variabl
find_result := find_symbol(checker, variable.typename, xx 1); find_result := find_symbol(checker, variable.typename, xx 1);
assert(find_result != null, "Internal compiler error\n"); assert(find_result != null, "Internal compiler error\n");
type_var := h2tv(checker, find_result.type_variable); type_var := from_handle(checker, find_result.type_variable);
for i : 0..type_var.children.count - 1 { for i : 0..type_var.children.count - 1 {
child := type_var.children[i]; child := type_var.children[i];
child_field := type_variable_to_field(checker, h2tv(checker, child)); child_field := type_variable_to_field(checker, from_handle(checker, child));
array_add(*type.children, child_field); array_add(*type.children, child_field);
} }
@@ -368,9 +372,9 @@ compile_file :: (compiler : *Shader_Compiler, paths : []string) -> Compile_Resul
} }
lex(*result); lex(*result);
// parse(*result); parse(*result);
// check(*result); check(*result);
// codegen(*result); codegen(*result);
return result; return result;
} }
@@ -435,7 +439,7 @@ compile_file :: (compiler : *Shader_Compiler, path : string) -> Compilation_Resu
if checker.result.vertex_entry_point { if checker.result.vertex_entry_point {
variant.vertex_entry_point.name = checker.result.vertex_entry_point.name; variant.vertex_entry_point.name = checker.result.vertex_entry_point.name;
type_variable := h2tv(*checker, checker.result.vertex_entry_point.type_variable); type_variable := from_handle(*checker, checker.result.vertex_entry_point.type_variable);
assert(type_variable.type == .Function); assert(type_variable.type == .Function);
node := type_variable.source_node; node := type_variable.source_node;
@@ -443,7 +447,7 @@ compile_file :: (compiler : *Shader_Compiler, path : string) -> Compilation_Resu
if node.children[0].kind == .FieldList { if node.children[0].kind == .FieldList {
field_list := node.children[0]; field_list := node.children[0];
for child : field_list.children { for child : field_list.children {
tv := h2tv(*checker, child.type_variable); tv := from_handle(*checker, child.type_variable);
field := type_variable_to_field(*checker, tv); field := type_variable_to_field(*checker, tv);
array_add(*variant.vertex_entry_point.input, field); array_add(*variant.vertex_entry_point.input, field);
} }
@@ -452,14 +456,14 @@ compile_file :: (compiler : *Shader_Compiler, path : string) -> Compilation_Resu
} }
for buffer_variable : to_array(*check_result.constant_buffers) { for buffer_variable : to_array(*check_result.constant_buffers) {
variable := h2tv(check_result.type_variables, buffer_variable); variable := from_handle(check_result.type_variables, buffer_variable);
cb := array_add(*result.collection.cbuffers); cb := array_add(*result.collection.cbuffers);
for i : 0..variable.children.count - 1 { for i : 0..variable.children.count - 1 {
child := variable.children[i]; child := variable.children[i];
field : Property_Field; field : Property_Field;
field.base_field = type_variable_to_field(*checker, h2tv(*checker, child));; field.base_field = type_variable_to_field(*checker, from_handle(*checker, child));;
array_add(*cb.fields, field); array_add(*cb.fields, field);
} }
@@ -468,11 +472,11 @@ compile_file :: (compiler : *Shader_Compiler, path : string) -> Compilation_Resu
find_result := find_symbol(*check_result.scope_stack, check_result.property_name, xx 1); find_result := find_symbol(*check_result.scope_stack, check_result.property_name, xx 1);
if find_result { if find_result {
property_variable := h2tv(check_result.type_variables, find_result.type_variable); property_variable := from_handle(check_result.type_variables, find_result.type_variable);
for i : 0..property_variable.children.count - 1 { for i : 0..property_variable.children.count - 1 {
child := property_variable.children[i]; child := property_variable.children[i];
field := type_variable_to_field(*checker, h2tv(*checker, child)); field := type_variable_to_field(*checker, from_handle(*checker, child));
prop_field : Property_Field; prop_field : Property_Field;
prop_field.base_field = field; prop_field.base_field = field;
array_add(*result.collection.properties.fields, prop_field); array_add(*result.collection.properties.fields, prop_field);
@@ -483,7 +487,7 @@ compile_file :: (compiler : *Shader_Compiler, path : string) -> Compilation_Resu
if checker.result.pixel_entry_point { if checker.result.pixel_entry_point {
variant.pixel_entry_point.name = checker.result.pixel_entry_point.name; variant.pixel_entry_point.name = checker.result.pixel_entry_point.name;
type_variable := h2tv(*checker, checker.result.pixel_entry_point.type_variable); type_variable := from_handle(*checker, checker.result.pixel_entry_point.type_variable);
assert(type_variable.type == .Function); assert(type_variable.type == .Function);
field := type_variable_to_field(*checker, type_variable.return_type_variable); field := type_variable_to_field(*checker, type_variable.return_type_variable);

24
test/all.suite
View File

@@ -1,12 +1,12 @@
test/assign_arithmetic_expression.shd lex parse test/assign_arithmetic_expression.inx lex parse
test/empty_vertex_main.shd lex parse test/empty_vertex_main.inx lex parse
test/empty_vertex_main_with_position_parameter.shd lex parse test/empty_vertex_main_with_position_parameter.inx lex parse
test/meta_block.shd lex parse test/meta_block.inx lex parse
test/basic_property_and_return_value.shd lex parse test/basic_property_and_return_value.inx lex parse
test/function_call_return.shd lex parse test/function_call_return.inx lex parse
test/struct_field_access_test.shd lex parse test/struct_field_access_test.inx lex parse
test/pass_and_access_struct_fields_in_functions.shd lex parse test/pass_and_access_struct_fields_in_functions.inx lex parse
test/field_without_type_specifier.shd lex parse test/field_without_type_specifier.inx lex parse
test/functions_with_same_name.shd lex parse test/functions_with_same_name.inx lex parse
test/function_with_int_return.shd lex parse test/function_with_int_return.inx lex parse
test/type_as_variable_name.shd lex parse test/type_as_variable_name.inx lex parse

0
test/arrays.shd → test/arrays.ink
View File

0
test/assign_arithmetic_expression.shd → test/assign_arithmetic_expression.ink
View File

0
test/basic_property_and_return_value.shd → test/basic_property_and_return_value.ink
View File

18
test/codegen/constant_buffer.golden Normal file
View File

@@ -0,0 +1,18 @@
cbuffer camera : register(b0)
{
float4x4 projection;
float4x4 view;
}
float4 vs_main(float4 pos : POSITION) : SV_POSITION
{
float4 mv = mul(camera.view, pos);
float4 mvp = mul(camera.projection, mv);
return mvp;
}
float4 ps_main() : SV_TARGET
{
return float4(0.5f, 0.5f, 0.5f, 1.0f);
}

5
test/codegen/property_rename.golden
View File

@@ -1,8 +1,9 @@
cbuffer __PROPERTIES : register(b0) cbuffer __PROPERTIES : register(b0)
{ {
float4 color; float4 __PROPERTIES__color;
} }
float4 vs_main(float4 pos : POSITION) : SV_POSITION float4 vs_main(float4 pos : POSITION) : SV_POSITION
{ {
return pos; return pos;
@@ -10,6 +11,6 @@ float4 vs_main(float4 pos : POSITION) : SV_POSITION
float4 ps_main() : SV_TARGET float4 ps_main() : SV_TARGET
{ {
return color; return __PROPERTIES__color;
} }

40
test/codegen_all.suite
View File

@@ -1,20 +1,20 @@
test/assign_arithmetic_expression.shd codegen test/assign_arithmetic_expression.ink codegen
test/basic_property_and_return_value.shd codegen test/basic_property_and_return_value.ink codegen
test/complicated_computation.shd codegen test/complicated_computation.ink codegen
test/constant_buffer.shd codegen test/constant_buffer.ink codegen
test/empty_struct.shd codegen test/empty_struct.ink codegen
test/empty_vertex_main.shd codegen test/empty_vertex_main.ink codegen
test/empty_vertex_main_with_position_parameter.shd codegen test/empty_vertex_main_with_position_parameter.ink codegen
test/field_assignment.shd codegen test/field_assignment.ink codegen
test/function_call.shd codegen test/function_call.ink codegen
test/function_call_out_of_order_declaration.shd codegen test/function_call_out_of_order_declaration.ink codegen
test/function_call_return.shd codegen test/function_call_return.ink codegen
test/meta_block.shd codegen test/meta_block.ink codegen
test/multiple_functions.shd codegen test/multiple_functions.ink codegen
test/multiple_semicolons_everywhere.shd codegen test/multiple_semicolons_everywhere.ink codegen
test/pass_and_access_struct_fields_in_functions.shd codegen test/pass_and_access_struct_fields_in_functions.ink codegen
test/passthrough.shd codegen test/passthrough.ink codegen
test/property_rename.shd codegen test/property_rename.ink codegen
test/simple_struct_access.shd codegen test/simple_struct_access.ink codegen
test/struct_within_struct.shd codegen test/struct_within_struct.ink codegen
test/use_builtin_functions.shd codegen test/use_builtin_functions.ink codegen

40
test/compile_all.suite
View File

@@ -1,20 +1,20 @@
test/assign_arithmetic_expression.shd compile test/assign_arithmetic_expression.ink compile
test/basic_property_and_return_value.shd compile test/basic_property_and_return_value.ink compile
test/complicated_computation.shd compile test/complicated_computation.ink compile
test/empty_struct.shd compile test/empty_struct.ink compile
test/empty_vertex_main.shd compile test/empty_vertex_main.ink compile
test/empty_vertex_main_with_position_parameter.shd compile test/empty_vertex_main_with_position_parameter.ink compile
test/field_assignment.shd compile test/field_assignment.ink compile
test/float_suffix.shd compile test/float_suffix.ink compile
test/function_call.shd compile test/function_call.ink compile
test/function_call_out_of_order_declaration.shd compile test/function_call_out_of_order_declaration.ink compile
test/function_call_return.shd compile test/function_call_return.ink compile
test/functions_with_same_name.shd compile test/functions_with_same_name.ink compile
test/meta_block.shd compile test/meta_block.ink compile
test/multiple_functions.shd compile test/multiple_functions.ink compile
test/multiple_semicolons_everywhere.shd compile test/multiple_semicolons_everywhere.ink compile
test/pass_and_access_struct_fields_in_functions.shd compile test/pass_and_access_struct_fields_in_functions.ink compile
test/passthrough.shd compile test/passthrough.ink compile
test/simple_struct_access.shd compile test/simple_struct_access.ink compile
test/struct_within_struct.shd compile test/struct_within_struct.ink compile
test/use_builtin_functions.shd compile test/use_builtin_functions.ink compile

0
test/complicated_computation.shd → test/complicated_computation.ink
View File

0
test/constant_buffer.shd → test/constant_buffer.ink
View File

0
test/double_access.shd → test/double_access.ink
View File

0
test/empty_struct.shd → test/empty_struct.ink
View File

0
test/empty_vertex_main.shd → test/empty_vertex_main.ink
View File

0
test/empty_vertex_main_with_position_parameter.shd → test/empty_vertex_main_with_position_parameter.ink
View File

0
test/field_assignment.shd → test/field_assignment.ink
View File

0
test/field_without_type_specifier.shd → test/field_without_type_specifier.ink
View File

0
test/float_suffix.shd → test/float_suffix.ink
View File

0
test/function_call.shd → test/function_call.ink
View File

0
test/function_call_out_of_order_declaration.shd → test/function_call_out_of_order_declaration.ink
View File

0
test/function_call_return.shd → test/function_call_return.ink
View File

0
test/function_with_int_return.shd → test/function_with_int_return.ink
View File

0
test/functions_with_same_name.shd → test/functions_with_same_name.ink
View File

0
test/large_block.shd → test/large_block.ink
View File

148
test/lex/constant_buffer.golden
View File

@@ -1,66 +1,82 @@
{kind = TOKEN_IDENTIFIER; ; index = 0 ; length = 11 line = 1 ; column = 0 ; value ='Camera_Data'; } {kind = TOKEN_IDENTIFIER; ; index = 0 ; length = 6 line = 1 ; column = 0 ; value ='camera'; }
{kind = TOKEN_DOUBLECOLON; ; index = 12 ; length = 2 line = 1 ; column = 12 ; value ='::'; } {kind = TOKEN_DOUBLECOLON; ; index = 7 ; length = 2 line = 1 ; column = 7 ; value ='::'; }
{kind = TOKEN_CONSTANT_BUFFER; ; index = 15 ; length = 15 line = 1 ; column = 15 ; value ='constant_buffer'; } {kind = TOKEN_CONSTANT_BUFFER; ; index = 10 ; length = 15 line = 1 ; column = 10 ; value ='constant_buffer'; }
{kind = TOKEN_LEFTBRACE; ; index = 31 ; length = 1 line = 1 ; column = 31 ; value ='{'; } {kind = TOKEN_LEFTBRACE; ; index = 26 ; length = 1 line = 1 ; column = 26 ; value ='{'; }
{kind = TOKEN_IDENTIFIER; ; index = 35 ; length = 10 line = 2 ; column = 0 ; value ='projection'; } {kind = TOKEN_IDENTIFIER; ; index = 30 ; length = 10 line = 2 ; column = 0 ; value ='projection'; }
{kind = TOKEN_COLON; ; index = 46 ; length = 1 line = 2 ; column = 11 ; value =':'; } {kind = TOKEN_COLON; ; index = 41 ; length = 1 line = 2 ; column = 11 ; value =':'; }
{kind = TOKEN_IDENTIFIER; ; index = 48 ; length = 8 line = 2 ; column = 13 ; value ='float4x4'; } {kind = TOKEN_IDENTIFIER; ; index = 43 ; length = 8 line = 2 ; column = 13 ; value ='float4x4'; }
{kind = TOKEN_SEMICOLON; ; index = 56 ; length = 1 line = 2 ; column = 21 ; value =';'; } {kind = TOKEN_SEMICOLON; ; index = 51 ; length = 1 line = 2 ; column = 21 ; value =';'; }
{kind = TOKEN_IDENTIFIER; ; index = 60 ; length = 4 line = 3 ; column = 0 ; value ='view'; } {kind = TOKEN_IDENTIFIER; ; index = 55 ; length = 4 line = 3 ; column = 0 ; value ='view'; }
{kind = TOKEN_COLON; ; index = 71 ; length = 1 line = 3 ; column = 11 ; value =':'; } {kind = TOKEN_COLON; ; index = 66 ; length = 1 line = 3 ; column = 11 ; value =':'; }
{kind = TOKEN_IDENTIFIER; ; index = 73 ; length = 8 line = 3 ; column = 13 ; value ='float4x4'; } {kind = TOKEN_IDENTIFIER; ; index = 68 ; length = 8 line = 3 ; column = 13 ; value ='float4x4'; }
{kind = TOKEN_SEMICOLON; ; index = 81 ; length = 1 line = 3 ; column = 21 ; value =';'; } {kind = TOKEN_SEMICOLON; ; index = 76 ; length = 1 line = 3 ; column = 21 ; value =';'; }
{kind = TOKEN_RIGHTBRACE; ; index = 84 ; length = 1 line = 4 ; column = 0 ; value ='}'; } {kind = TOKEN_RIGHTBRACE; ; index = 79 ; length = 1 line = 4 ; column = 0 ; value ='}'; }
{kind = TOKEN_VERTEX; ; index = 89 ; length = 6 line = 6 ; column = 0 ; value ='vertex'; } {kind = TOKEN_VERTEX; ; index = 84 ; length = 6 line = 6 ; column = 0 ; value ='vertex'; }
{kind = TOKEN_IDENTIFIER; ; index = 96 ; length = 4 line = 6 ; column = 7 ; value ='main'; } {kind = TOKEN_IDENTIFIER; ; index = 91 ; length = 4 line = 6 ; column = 7 ; value ='main'; }
{kind = TOKEN_DOUBLECOLON; ; index = 101 ; length = 2 line = 6 ; column = 12 ; value ='::'; } {kind = TOKEN_DOUBLECOLON; ; index = 96 ; length = 2 line = 6 ; column = 12 ; value ='::'; }
{kind = TOKEN_LEFTPAREN; ; index = 104 ; length = 1 line = 6 ; column = 15 ; value ='('; } {kind = TOKEN_LEFTPAREN; ; index = 99 ; length = 1 line = 6 ; column = 15 ; value ='('; }
{kind = TOKEN_IDENTIFIER; ; index = 105 ; length = 3 line = 6 ; column = 16 ; value ='pos'; } {kind = TOKEN_IDENTIFIER; ; index = 100 ; length = 3 line = 6 ; column = 16 ; value ='pos'; }
{kind = TOKEN_COLON; ; index = 109 ; length = 1 line = 6 ; column = 20 ; value =':'; } {kind = TOKEN_COLON; ; index = 104 ; length = 1 line = 6 ; column = 20 ; value =':'; }
{kind = TOKEN_IDENTIFIER; ; index = 111 ; length = 6 line = 6 ; column = 22 ; value ='float4'; } {kind = TOKEN_IDENTIFIER; ; index = 106 ; length = 6 line = 6 ; column = 22 ; value ='float4'; }
{kind = TOKEN_AT; ; index = 118 ; length = 1 line = 6 ; column = 29 ; value ='@'; } {kind = TOKEN_AT; ; index = 113 ; length = 1 line = 6 ; column = 29 ; value ='@'; }
{kind = TOKEN_IDENTIFIER; ; index = 119 ; length = 8 line = 6 ; column = 30 ; value ='position'; } {kind = TOKEN_IDENTIFIER; ; index = 114 ; length = 8 line = 6 ; column = 30 ; value ='position'; }
{kind = TOKEN_RIGHTPAREN; ; index = 127 ; length = 1 line = 6 ; column = 38 ; value =')'; } {kind = TOKEN_RIGHTPAREN; ; index = 122 ; length = 1 line = 6 ; column = 38 ; value =')'; }
{kind = TOKEN_ARROW; ; index = 129 ; length = 2 line = 6 ; column = 40 ; value ='->'; } {kind = TOKEN_ARROW; ; index = 124 ; length = 2 line = 6 ; column = 40 ; value ='->'; }
{kind = TOKEN_IDENTIFIER; ; index = 132 ; length = 6 line = 6 ; column = 43 ; value ='float4'; } {kind = TOKEN_IDENTIFIER; ; index = 127 ; length = 6 line = 6 ; column = 43 ; value ='float4'; }
{kind = TOKEN_AT; ; index = 139 ; length = 1 line = 6 ; column = 50 ; value ='@'; } {kind = TOKEN_AT; ; index = 134 ; length = 1 line = 6 ; column = 50 ; value ='@'; }
{kind = TOKEN_IDENTIFIER; ; index = 140 ; length = 8 line = 6 ; column = 51 ; value ='position'; } {kind = TOKEN_IDENTIFIER; ; index = 135 ; length = 8 line = 6 ; column = 51 ; value ='position'; }
{kind = TOKEN_LEFTBRACE; ; index = 149 ; length = 1 line = 6 ; column = 60 ; value ='{'; } {kind = TOKEN_LEFTBRACE; ; index = 144 ; length = 1 line = 6 ; column = 60 ; value ='{'; }
{kind = TOKEN_RETURN; ; index = 153 ; length = 6 line = 7 ; column = 0 ; value ='return'; } {kind = TOKEN_IDENTIFIER; ; index = 148 ; length = 2 line = 7 ; column = 0 ; value ='mv'; }
{kind = TOKEN_IDENTIFIER; ; index = 160 ; length = 3 line = 7 ; column = 7 ; value ='mul'; } {kind = TOKEN_COLON; ; index = 151 ; length = 1 line = 7 ; column = 3 ; value =':'; }
{kind = TOKEN_LEFTPAREN; ; index = 163 ; length = 1 line = 7 ; column = 10 ; value ='('; } {kind = TOKEN_IDENTIFIER; ; index = 153 ; length = 6 line = 7 ; column = 5 ; value ='float4'; }
{kind = TOKEN_IDENTIFIER; ; index = 164 ; length = 10 line = 7 ; column = 11 ; value ='projection'; } {kind = TOKEN_ASSIGN; ; index = 160 ; length = 1 line = 7 ; column = 12 ; value ='='; }
{kind = TOKEN_COMMA; ; index = 174 ; length = 1 line = 7 ; column = 21 ; value =','; } {kind = TOKEN_IDENTIFIER; ; index = 162 ; length = 3 line = 7 ; column = 14 ; value ='mul'; }
{kind = TOKEN_IDENTIFIER; ; index = 176 ; length = 3 line = 7 ; column = 23 ; value ='mul'; } {kind = TOKEN_LEFTPAREN; ; index = 165 ; length = 1 line = 7 ; column = 17 ; value ='('; }
{kind = TOKEN_LEFTPAREN; ; index = 179 ; length = 1 line = 7 ; column = 26 ; value ='('; } {kind = TOKEN_IDENTIFIER; ; index = 166 ; length = 6 line = 7 ; column = 18 ; value ='camera'; }
{kind = TOKEN_IDENTIFIER; ; index = 180 ; length = 4 line = 7 ; column = 27 ; value ='view'; } {kind = TOKEN_DOT; ; index = 172 ; length = 1 line = 7 ; column = 24 ; value ='.'; }
{kind = TOKEN_COMMA; ; index = 184 ; length = 1 line = 7 ; column = 31 ; value =','; } {kind = TOKEN_IDENTIFIER; ; index = 173 ; length = 4 line = 7 ; column = 25 ; value ='view'; }
{kind = TOKEN_IDENTIFIER; ; index = 186 ; length = 3 line = 7 ; column = 33 ; value ='pos'; } {kind = TOKEN_COMMA; ; index = 177 ; length = 1 line = 7 ; column = 29 ; value =','; }
{kind = TOKEN_RIGHTPAREN; ; index = 189 ; length = 1 line = 7 ; column = 36 ; value =')'; } {kind = TOKEN_IDENTIFIER; ; index = 179 ; length = 3 line = 7 ; column = 31 ; value ='pos'; }
{kind = TOKEN_RIGHTPAREN; ; index = 190 ; length = 1 line = 7 ; column = 37 ; value =')'; } {kind = TOKEN_RIGHTPAREN; ; index = 182 ; length = 1 line = 7 ; column = 34 ; value =')'; }
{kind = TOKEN_SEMICOLON; ; index = 191 ; length = 1 line = 7 ; column = 38 ; value =';'; } {kind = TOKEN_SEMICOLON; ; index = 183 ; length = 1 line = 7 ; column = 35 ; value =';'; }
{kind = TOKEN_RIGHTBRACE; ; index = 194 ; length = 1 line = 8 ; column = 0 ; value ='}'; } {kind = TOKEN_IDENTIFIER; ; index = 187 ; length = 3 line = 8 ; column = 0 ; value ='mvp'; }
{kind = TOKEN_PIXEL; ; index = 199 ; length = 5 line = 10 ; column = 0 ; value ='pixel'; } {kind = TOKEN_COLON; ; index = 191 ; length = 1 line = 8 ; column = 4 ; value =':'; }
{kind = TOKEN_IDENTIFIER; ; index = 205 ; length = 4 line = 10 ; column = 6 ; value ='main'; } {kind = TOKEN_IDENTIFIER; ; index = 193 ; length = 6 line = 8 ; column = 6 ; value ='float4'; }
{kind = TOKEN_DOUBLECOLON; ; index = 210 ; length = 2 line = 10 ; column = 11 ; value ='::'; } {kind = TOKEN_ASSIGN; ; index = 200 ; length = 1 line = 8 ; column = 13 ; value ='='; }
{kind = TOKEN_LEFTPAREN; ; index = 213 ; length = 1 line = 10 ; column = 14 ; value ='('; } {kind = TOKEN_IDENTIFIER; ; index = 202 ; length = 3 line = 8 ; column = 15 ; value ='mul'; }
{kind = TOKEN_RIGHTPAREN; ; index = 214 ; length = 1 line = 10 ; column = 15 ; value =')'; } {kind = TOKEN_LEFTPAREN; ; index = 205 ; length = 1 line = 8 ; column = 18 ; value ='('; }
{kind = TOKEN_ARROW; ; index = 216 ; length = 2 line = 10 ; column = 17 ; value ='->'; } {kind = TOKEN_IDENTIFIER; ; index = 206 ; length = 6 line = 8 ; column = 19 ; value ='camera'; }
{kind = TOKEN_IDENTIFIER; ; index = 219 ; length = 6 line = 10 ; column = 20 ; value ='float4'; } {kind = TOKEN_DOT; ; index = 212 ; length = 1 line = 8 ; column = 25 ; value ='.'; }
{kind = TOKEN_AT; ; index = 226 ; length = 1 line = 10 ; column = 27 ; value ='@'; } {kind = TOKEN_IDENTIFIER; ; index = 213 ; length = 10 line = 8 ; column = 26 ; value ='projection'; }
{kind = TOKEN_IDENTIFIER; ; index = 227 ; length = 6 line = 10 ; column = 28 ; value ='target'; } {kind = TOKEN_COMMA; ; index = 223 ; length = 1 line = 8 ; column = 36 ; value =','; }
{kind = TOKEN_LEFTBRACE; ; index = 234 ; length = 1 line = 10 ; column = 35 ; value ='{'; } {kind = TOKEN_IDENTIFIER; ; index = 225 ; length = 2 line = 8 ; column = 38 ; value ='mv'; }
{kind = TOKEN_RETURN; ; index = 238 ; length = 6 line = 11 ; column = 0 ; value ='return'; } {kind = TOKEN_RIGHTPAREN; ; index = 227 ; length = 1 line = 8 ; column = 40 ; value =')'; }
{kind = TOKEN_IDENTIFIER; ; index = 245 ; length = 5 line = 11 ; column = 7 ; value ='float'; } {kind = TOKEN_SEMICOLON; ; index = 228 ; length = 1 line = 8 ; column = 41 ; value =';'; }
{kind = TOKEN_LEFTPAREN; ; index = 250 ; length = 1 line = 11 ; column = 12 ; value ='('; } {kind = TOKEN_RETURN; ; index = 232 ; length = 6 line = 9 ; column = 0 ; value ='return'; }
{kind = TOKEN_FLOATLITERAL; ; index = 251 ; length = 3 line = 11 ; column = 13 ; value ='0.5'; } {kind = TOKEN_IDENTIFIER; ; index = 239 ; length = 3 line = 9 ; column = 7 ; value ='mvp'; }
{kind = TOKEN_COMMA; ; index = 254 ; length = 1 line = 11 ; column = 16 ; value =','; } {kind = TOKEN_SEMICOLON; ; index = 242 ; length = 1 line = 9 ; column = 10 ; value =';'; }
{kind = TOKEN_FLOATLITERAL; ; index = 256 ; length = 3 line = 11 ; column = 18 ; value ='0.5'; } {kind = TOKEN_RIGHTBRACE; ; index = 245 ; length = 1 line = 10 ; column = 0 ; value ='}'; }
{kind = TOKEN_COMMA; ; index = 259 ; length = 1 line = 11 ; column = 21 ; value =','; } {kind = TOKEN_PIXEL; ; index = 250 ; length = 5 line = 12 ; column = 0 ; value ='pixel'; }
{kind = TOKEN_FLOATLITERAL; ; index = 261 ; length = 3 line = 11 ; column = 23 ; value ='0.5'; } {kind = TOKEN_IDENTIFIER; ; index = 256 ; length = 4 line = 12 ; column = 6 ; value ='main'; }
{kind = TOKEN_COMMA; ; index = 264 ; length = 1 line = 11 ; column = 26 ; value =','; } {kind = TOKEN_DOUBLECOLON; ; index = 261 ; length = 2 line = 12 ; column = 11 ; value ='::'; }
{kind = TOKEN_FLOATLITERAL; ; index = 266 ; length = 3 line = 11 ; column = 28 ; value ='1'; } {kind = TOKEN_LEFTPAREN; ; index = 264 ; length = 1 line = 12 ; column = 14 ; value ='('; }
{kind = TOKEN_RIGHTPAREN; ; index = 269 ; length = 1 line = 11 ; column = 31 ; value =')'; } {kind = TOKEN_RIGHTPAREN; ; index = 265 ; length = 1 line = 12 ; column = 15 ; value =')'; }
{kind = TOKEN_SEMICOLON; ; index = 270 ; length = 1 line = 11 ; column = 32 ; value =';'; } {kind = TOKEN_ARROW; ; index = 267 ; length = 2 line = 12 ; column = 17 ; value ='->'; }
{kind = TOKEN_RIGHTBRACE; ; index = 273 ; length = 1 line = 12 ; column = 0 ; value ='}'; } {kind = TOKEN_IDENTIFIER; ; index = 270 ; length = 6 line = 12 ; column = 20 ; value ='float4'; }
{kind = TOKEN_EOF; ; index = 276 ; length = 0 line = 13 ; column = 0 ; value =''; } {kind = TOKEN_AT; ; index = 277 ; length = 1 line = 12 ; column = 27 ; value ='@'; }
{kind = TOKEN_IDENTIFIER; ; index = 278 ; length = 6 line = 12 ; column = 28 ; value ='target'; }
{kind = TOKEN_LEFTBRACE; ; index = 285 ; length = 1 line = 12 ; column = 35 ; value ='{'; }
{kind = TOKEN_RETURN; ; index = 289 ; length = 6 line = 13 ; column = 0 ; value ='return'; }
{kind = TOKEN_IDENTIFIER; ; index = 296 ; length = 6 line = 13 ; column = 7 ; value ='float4'; }
{kind = TOKEN_LEFTPAREN; ; index = 302 ; length = 1 line = 13 ; column = 13 ; value ='('; }
{kind = TOKEN_FLOATLITERAL; ; index = 303 ; length = 3 line = 13 ; column = 14 ; value ='0.5'; }
{kind = TOKEN_COMMA; ; index = 306 ; length = 1 line = 13 ; column = 17 ; value =','; }
{kind = TOKEN_FLOATLITERAL; ; index = 308 ; length = 3 line = 13 ; column = 19 ; value ='0.5'; }
{kind = TOKEN_COMMA; ; index = 311 ; length = 1 line = 13 ; column = 22 ; value =','; }
{kind = TOKEN_FLOATLITERAL; ; index = 313 ; length = 3 line = 13 ; column = 24 ; value ='0.5'; }
{kind = TOKEN_COMMA; ; index = 316 ; length = 1 line = 13 ; column = 27 ; value =','; }
{kind = TOKEN_FLOATLITERAL; ; index = 318 ; length = 3 line = 13 ; column = 29 ; value ='1'; }
{kind = TOKEN_RIGHTPAREN; ; index = 321 ; length = 1 line = 13 ; column = 32 ; value =')'; }
{kind = TOKEN_SEMICOLON; ; index = 322 ; length = 1 line = 13 ; column = 33 ; value =';'; }
{kind = TOKEN_RIGHTBRACE; ; index = 325 ; length = 1 line = 14 ; column = 0 ; value ='}'; }
{kind = TOKEN_EOF; ; index = 328 ; length = 0 line = 15 ; column = 0 ; value =''; }

2
test/lex/float_suffix.golden
View File

@@ -1,4 +1,4 @@
test/float_suffix.shd:2,12: error: We don't use 'f' suffixes for floating point values. test/float_suffix.inx:2,12: error: We don't use 'f' suffixes for floating point values.
 x : float = 2.0f  x : float = 2.0f
^^^^ ^^^^
 

90
test/lex/property_rename.golden
View File

@@ -1,45 +1,45 @@
{kind = TOKEN_IDENTIFIER; ; index = 0 ; length = 5 line = 1 ; column = 0 ; value ='props'; } {kind = TOKEN_IDENTIFIER; ; index = 0 ; length = 5 line = 1 ; column = 0 ; value ='props'; }
{kind = TOKEN_COLON; ; index = 6 ; length = 1 line = 1 ; column = 6 ; value =':'; } {kind = TOKEN_DOUBLECOLON; ; index = 6 ; length = 2 line = 1 ; column = 6 ; value ='::'; }
{kind = TOKEN_PROPERTIES; ; index = 8 ; length = 10 line = 1 ; column = 8 ; value ='properties'; } {kind = TOKEN_PROPERTIES; ; index = 9 ; length = 10 line = 1 ; column = 9 ; value ='properties'; }
{kind = TOKEN_LEFTBRACE; ; index = 19 ; length = 1 line = 1 ; column = 19 ; value ='{'; } {kind = TOKEN_LEFTBRACE; ; index = 20 ; length = 1 line = 1 ; column = 20 ; value ='{'; }
{kind = TOKEN_IDENTIFIER; ; index = 23 ; length = 5 line = 2 ; column = 0 ; value ='color'; } {kind = TOKEN_IDENTIFIER; ; index = 24 ; length = 5 line = 2 ; column = 0 ; value ='color'; }
{kind = TOKEN_COLON; ; index = 29 ; length = 1 line = 2 ; column = 6 ; value =':'; } {kind = TOKEN_COLON; ; index = 30 ; length = 1 line = 2 ; column = 6 ; value =':'; }
{kind = TOKEN_IDENTIFIER; ; index = 31 ; length = 6 line = 2 ; column = 8 ; value ='float4'; } {kind = TOKEN_IDENTIFIER; ; index = 32 ; length = 6 line = 2 ; column = 8 ; value ='float4'; }
{kind = TOKEN_SEMICOLON; ; index = 37 ; length = 1 line = 2 ; column = 14 ; value =';'; } {kind = TOKEN_SEMICOLON; ; index = 38 ; length = 1 line = 2 ; column = 14 ; value =';'; }
{kind = TOKEN_RIGHTBRACE; ; index = 40 ; length = 1 line = 3 ; column = 0 ; value ='}'; } {kind = TOKEN_RIGHTBRACE; ; index = 41 ; length = 1 line = 3 ; column = 0 ; value ='}'; }
{kind = TOKEN_VERTEX; ; index = 45 ; length = 6 line = 5 ; column = 0 ; value ='vertex'; } {kind = TOKEN_VERTEX; ; index = 46 ; length = 6 line = 5 ; column = 0 ; value ='vertex'; }
{kind = TOKEN_IDENTIFIER; ; index = 52 ; length = 4 line = 5 ; column = 7 ; value ='main'; } {kind = TOKEN_IDENTIFIER; ; index = 53 ; length = 4 line = 5 ; column = 7 ; value ='main'; }
{kind = TOKEN_DOUBLECOLON; ; index = 57 ; length = 2 line = 5 ; column = 12 ; value ='::'; } {kind = TOKEN_DOUBLECOLON; ; index = 58 ; length = 2 line = 5 ; column = 12 ; value ='::'; }
{kind = TOKEN_LEFTPAREN; ; index = 60 ; length = 1 line = 5 ; column = 15 ; value ='('; } {kind = TOKEN_LEFTPAREN; ; index = 61 ; length = 1 line = 5 ; column = 15 ; value ='('; }
{kind = TOKEN_IDENTIFIER; ; index = 61 ; length = 3 line = 5 ; column = 16 ; value ='pos'; } {kind = TOKEN_IDENTIFIER; ; index = 62 ; length = 3 line = 5 ; column = 16 ; value ='pos'; }
{kind = TOKEN_COLON; ; index = 65 ; length = 1 line = 5 ; column = 20 ; value =':'; } {kind = TOKEN_COLON; ; index = 66 ; length = 1 line = 5 ; column = 20 ; value =':'; }
{kind = TOKEN_IDENTIFIER; ; index = 67 ; length = 6 line = 5 ; column = 22 ; value ='float4'; } {kind = TOKEN_IDENTIFIER; ; index = 68 ; length = 6 line = 5 ; column = 22 ; value ='float4'; }
{kind = TOKEN_AT; ; index = 74 ; length = 1 line = 5 ; column = 29 ; value ='@'; } {kind = TOKEN_AT; ; index = 75 ; length = 1 line = 5 ; column = 29 ; value ='@'; }
{kind = TOKEN_IDENTIFIER; ; index = 75 ; length = 8 line = 5 ; column = 30 ; value ='position'; } {kind = TOKEN_IDENTIFIER; ; index = 76 ; length = 8 line = 5 ; column = 30 ; value ='position'; }
{kind = TOKEN_RIGHTPAREN; ; index = 83 ; length = 1 line = 5 ; column = 38 ; value =')'; } {kind = TOKEN_RIGHTPAREN; ; index = 84 ; length = 1 line = 5 ; column = 38 ; value =')'; }
{kind = TOKEN_ARROW; ; index = 85 ; length = 2 line = 5 ; column = 40 ; value ='->'; } {kind = TOKEN_ARROW; ; index = 86 ; length = 2 line = 5 ; column = 40 ; value ='->'; }
{kind = TOKEN_IDENTIFIER; ; index = 88 ; length = 6 line = 5 ; column = 43 ; value ='float4'; } {kind = TOKEN_IDENTIFIER; ; index = 89 ; length = 6 line = 5 ; column = 43 ; value ='float4'; }
{kind = TOKEN_AT; ; index = 95 ; length = 1 line = 5 ; column = 50 ; value ='@'; } {kind = TOKEN_AT; ; index = 96 ; length = 1 line = 5 ; column = 50 ; value ='@'; }
{kind = TOKEN_IDENTIFIER; ; index = 96 ; length = 8 line = 5 ; column = 51 ; value ='position'; } {kind = TOKEN_IDENTIFIER; ; index = 97 ; length = 8 line = 5 ; column = 51 ; value ='position'; }
{kind = TOKEN_LEFTBRACE; ; index = 105 ; length = 1 line = 5 ; column = 60 ; value ='{'; } {kind = TOKEN_LEFTBRACE; ; index = 106 ; length = 1 line = 5 ; column = 60 ; value ='{'; }
{kind = TOKEN_RETURN; ; index = 109 ; length = 6 line = 6 ; column = 0 ; value ='return'; } {kind = TOKEN_RETURN; ; index = 110 ; length = 6 line = 6 ; column = 0 ; value ='return'; }
{kind = TOKEN_IDENTIFIER; ; index = 116 ; length = 3 line = 6 ; column = 7 ; value ='pos'; } {kind = TOKEN_IDENTIFIER; ; index = 117 ; length = 3 line = 6 ; column = 7 ; value ='pos'; }
{kind = TOKEN_SEMICOLON; ; index = 119 ; length = 1 line = 6 ; column = 10 ; value =';'; } {kind = TOKEN_SEMICOLON; ; index = 120 ; length = 1 line = 6 ; column = 10 ; value =';'; }
{kind = TOKEN_RIGHTBRACE; ; index = 122 ; length = 1 line = 7 ; column = 0 ; value ='}'; } {kind = TOKEN_RIGHTBRACE; ; index = 123 ; length = 1 line = 7 ; column = 0 ; value ='}'; }
{kind = TOKEN_PIXEL; ; index = 127 ; length = 5 line = 9 ; column = 0 ; value ='pixel'; } {kind = TOKEN_PIXEL; ; index = 128 ; length = 5 line = 9 ; column = 0 ; value ='pixel'; }
{kind = TOKEN_IDENTIFIER; ; index = 133 ; length = 4 line = 9 ; column = 6 ; value ='main'; } {kind = TOKEN_IDENTIFIER; ; index = 134 ; length = 4 line = 9 ; column = 6 ; value ='main'; }
{kind = TOKEN_DOUBLECOLON; ; index = 138 ; length = 2 line = 9 ; column = 11 ; value ='::'; } {kind = TOKEN_DOUBLECOLON; ; index = 139 ; length = 2 line = 9 ; column = 11 ; value ='::'; }
{kind = TOKEN_LEFTPAREN; ; index = 141 ; length = 1 line = 9 ; column = 14 ; value ='('; } {kind = TOKEN_LEFTPAREN; ; index = 142 ; length = 1 line = 9 ; column = 14 ; value ='('; }
{kind = TOKEN_RIGHTPAREN; ; index = 142 ; length = 1 line = 9 ; column = 15 ; value =')'; } {kind = TOKEN_RIGHTPAREN; ; index = 143 ; length = 1 line = 9 ; column = 15 ; value =')'; }
{kind = TOKEN_ARROW; ; index = 144 ; length = 2 line = 9 ; column = 17 ; value ='->'; } {kind = TOKEN_ARROW; ; index = 145 ; length = 2 line = 9 ; column = 17 ; value ='->'; }
{kind = TOKEN_IDENTIFIER; ; index = 147 ; length = 6 line = 9 ; column = 20 ; value ='float4'; } {kind = TOKEN_IDENTIFIER; ; index = 148 ; length = 6 line = 9 ; column = 20 ; value ='float4'; }
{kind = TOKEN_AT; ; index = 154 ; length = 1 line = 9 ; column = 27 ; value ='@'; } {kind = TOKEN_AT; ; index = 155 ; length = 1 line = 9 ; column = 27 ; value ='@'; }
{kind = TOKEN_IDENTIFIER; ; index = 155 ; length = 7 line = 9 ; column = 28 ; value ='target0'; } {kind = TOKEN_IDENTIFIER; ; index = 156 ; length = 7 line = 9 ; column = 28 ; value ='target0'; }
{kind = TOKEN_LEFTBRACE; ; index = 163 ; length = 1 line = 9 ; column = 36 ; value ='{'; } {kind = TOKEN_LEFTBRACE; ; index = 164 ; length = 1 line = 9 ; column = 36 ; value ='{'; }
{kind = TOKEN_RETURN; ; index = 169 ; length = 6 line = 10 ; column = 2 ; value ='return'; } {kind = TOKEN_RETURN; ; index = 170 ; length = 6 line = 10 ; column = 2 ; value ='return'; }
{kind = TOKEN_IDENTIFIER; ; index = 176 ; length = 5 line = 10 ; column = 9 ; value ='props'; } {kind = TOKEN_IDENTIFIER; ; index = 177 ; length = 5 line = 10 ; column = 9 ; value ='props'; }
{kind = TOKEN_DOT; ; index = 181 ; length = 1 line = 10 ; column = 14 ; value ='.'; } {kind = TOKEN_DOT; ; index = 182 ; length = 1 line = 10 ; column = 14 ; value ='.'; }
{kind = TOKEN_IDENTIFIER; ; index = 182 ; length = 5 line = 10 ; column = 15 ; value ='color'; } {kind = TOKEN_IDENTIFIER; ; index = 183 ; length = 5 line = 10 ; column = 15 ; value ='color'; }
{kind = TOKEN_SEMICOLON; ; index = 187 ; length = 1 line = 10 ; column = 20 ; value =';'; } {kind = TOKEN_SEMICOLON; ; index = 188 ; length = 1 line = 10 ; column = 20 ; value =';'; }
{kind = TOKEN_RIGHTBRACE; ; index = 190 ; length = 1 line = 11 ; column = 0 ; value ='}'; } {kind = TOKEN_RIGHTBRACE; ; index = 191 ; length = 1 line = 11 ; column = 0 ; value ='}'; }
{kind = TOKEN_EOF; ; index = 193 ; length = 0 line = 12 ; column = 0 ; value =''; } {kind = TOKEN_EOF; ; index = 194 ; length = 0 line = 12 ; column = 0 ; value =''; }

66
test/lex_all.suite
View File

@@ -1,33 +1,33 @@
test/assign_arithmetic_expression.shd lex test/assign_arithmetic_expression.ink lex
test/basic_property_and_return_value.shd lex test/basic_property_and_return_value.ink lex
test/complicated_computation.shd lex test/complicated_computation.ink lex
test/constant_buffer.shd lex test/constant_buffer.ink lex
test/empty_struct.shd lex test/empty_struct.ink lex
test/empty_vertex_main.shd lex test/empty_vertex_main.ink lex
test/empty_vertex_main_with_position_parameter.shd lex test/empty_vertex_main_with_position_parameter.ink lex
test/field_assignment.shd lex test/field_assignment.ink lex
test/field_without_type_specifier.shd lex test/field_without_type_specifier.ink lex
test/float_suffix.shd lex test/float_suffix.ink lex
test/function_call.shd lex test/function_call.ink lex
test/function_call_out_of_order_declaration.shd lex test/function_call_out_of_order_declaration.ink lex
test/function_call_return.shd lex test/function_call_return.ink lex
test/functions_with_same_name.shd lex test/functions_with_same_name.ink lex
test/function_with_int_return.shd lex test/function_with_int_return.ink lex
test/meta_block.shd lex test/meta_block.ink lex
test/multiple_functions.shd lex test/multiple_functions.ink lex
test/multiple_semicolons_everywhere.shd lex test/multiple_semicolons_everywhere.ink lex
test/pass_and_access_struct_fields_in_functions.shd lex test/pass_and_access_struct_fields_in_functions.ink lex
test/passthrough.shd lex test/passthrough.ink lex
test/property_rename.shd lex test/property_rename.ink lex
test/redeclared_variable.shd lex test/redeclared_variable.ink lex
test/simple_struct_access.shd lex test/simple_struct_access.ink lex
test/struct_access_primitive_type.shd lex test/struct_access_primitive_type.ink lex
test/struct_within_struct.shd lex test/struct_within_struct.ink lex
test/type_as_variable_name.shd lex test/type_as_variable_name.ink lex
test/undeclared_function.shd lex test/undeclared_function.ink lex
test/undeclared_symbol.shd lex test/undeclared_symbol.ink lex
test/unknown_overload.shd lex test/unknown_overload.ink lex
test/use_builtin_functions.shd lex test/use_builtin_functions.ink lex
test/wrong_argument_count.shd lex test/wrong_argument_count.ink lex
test/wrong_multiply.shd lex test/wrong_multiply.ink lex
test/wrong_type_for_function.shd lex test/wrong_type_for_function.ink lex

0
test/meta_block.shd → test/meta_block.ink
View File

0
test/multiple_functions.shd → test/multiple_functions.ink
View File

0
test/multiple_semicolons_everywhere.shd → test/multiple_semicolons_everywhere.ink
View File

14
test/parse/constant_buffer.golden Normal file
View File

@@ -0,0 +1,14 @@
(program
(constant_buffer camera
[(:= projection float4x4)
(:= view float4x4)])
(fun vertex vs_main -> float4 (@position)
[(:= pos float4 (@position))]
(:= mv float4 (mul camera.view pos))
(:= mvp float4 (mul camera.projection mv))
(return mvp))
(fun pixel ps_main -> float4 (@target)
[]
(return (float4 0.5 0.5 0.5 1))))

2
test/parse/field_without_type_specifier.golden
View File

@@ -1,4 +1,4 @@
test/field_without_type_specifier.shd:2,0: error: Expected type specifier after field name. test/field_without_type_specifier.inx:2,0: error: Expected type specifier after field name.
x := 5.0; x := 5.0;
^ ^
 

11
test/parse/property_rename.golden Normal file
View File

@@ -0,0 +1,11 @@
(program
(properties props
[(:= color float4)])
(fun vertex vs_main -> float4 (@position)
[(:= pos float4 (@position))]
(return pos))
(fun pixel ps_main -> float4 (@target0)
[]
(return props.color)))

66
test/parse_all.suite
View File

@@ -1,33 +1,33 @@
test/assign_arithmetic_expression.shd parse test/assign_arithmetic_expression.ink parse
test/basic_property_and_return_value.shd parse test/basic_property_and_return_value.ink parse
test/complicated_computation.shd parse test/complicated_computation.ink parse
test/constant_buffer.shd parse test/constant_buffer.ink parse
test/empty_struct.shd parse test/empty_struct.ink parse
test/empty_vertex_main.shd parse test/empty_vertex_main.ink parse
test/empty_vertex_main_with_position_parameter.shd parse test/empty_vertex_main_with_position_parameter.ink parse
test/field_assignment.shd parse test/field_assignment.ink parse
test/field_without_type_specifier.shd parse test/field_without_type_specifier.ink parse
test/float_suffix.shd parse test/float_suffix.ink parse
test/function_call.shd parse test/function_call.ink parse
test/function_call_out_of_order_declaration.shd parse test/function_call_out_of_order_declaration.ink parse
test/function_call_return.shd parse test/function_call_return.ink parse
test/functions_with_same_name.shd parse test/functions_with_same_name.ink parse
test/function_with_int_return.shd parse test/function_with_int_return.ink parse
test/meta_block.shd parse test/meta_block.ink parse
test/multiple_functions.shd parse test/multiple_functions.ink parse
test/multiple_semicolons_everywhere.shd parse test/multiple_semicolons_everywhere.ink parse
test/pass_and_access_struct_fields_in_functions.shd parse test/pass_and_access_struct_fields_in_functions.ink parse
test/passthrough.shd parse test/passthrough.ink parse
test/property_rename.shd parse test/property_rename.ink parse
test/redeclared_variable.shd parse test/redeclared_variable.ink parse
test/simple_struct_access.shd parse test/simple_struct_access.ink parse
test/struct_access_primitive_type.shd parse test/struct_access_primitive_type.ink parse
test/struct_within_struct.shd parse test/struct_within_struct.ink parse
test/type_as_variable_name.shd parse test/type_as_variable_name.ink parse
test/undeclared_function.shd parse test/undeclared_function.ink parse
test/undeclared_symbol.shd parse test/undeclared_symbol.ink parse
test/unknown_overload.shd parse test/unknown_overload.ink parse
test/use_builtin_functions.shd parse test/use_builtin_functions.ink parse
test/wrong_argument_count.shd parse test/wrong_argument_count.ink parse
test/wrong_multiply.shd parse test/wrong_multiply.ink parse
test/wrong_type_for_function.shd parse test/wrong_type_for_function.ink parse

0
test/pass_and_access_struct_fields_in_functions.shd → test/pass_and_access_struct_fields_in_functions.ink
View File

0
test/passthrough.shd → test/passthrough.ink
View File

0
test/precedence_test.shd → test/precedence_test.ink
View File

0
test/property_rename.shd → test/property_rename.ink
View File

0
test/redeclared_variable.shd → test/redeclared_variable.ink
View File

4
test/semant/functions_with_same_name.golden
View File

@@ -1,8 +1,8 @@
test/functions_with_same_name.shd:2,0: error: Redeclaration of 'foo' test/functions_with_same_name.inx:2,0: error: Redeclaration of 'foo'
 foo :: () {  foo :: () {
^^^ ^^^
test/functions_with_same_name.shd:1,0: info: Here is the first declaration of 'foo' test/functions_with_same_name.inx:1,0: info: Here is the first declaration of 'foo'
 foo :: () {  foo :: () {
^^^ ^^^
 

12
test/semant/property_rename.golden Normal file
View File

@@ -0,0 +1,12 @@
scope (global) [
[pixel__ps_main] : () -> float4
[vertex__vs_main] : (pos : float4) -> float4
[props] : {color : float4}
scope (props) [
[color] : float4
]
scope (vertex__vs_main) [
[pos] : float4
]
scope (pixel__ps_main) []
]

4
test/semant/redeclared_variable.golden
View File

@@ -1,8 +1,8 @@
test/redeclared_variable.shd:3,0: error: Redeclaration of 'x' test/redeclared_variable.inx:3,0: error: Redeclaration of 'x'
 x : float = 5.0  x : float = 5.0
^ ^
test/redeclared_variable.shd:2,0: info: Here is the first declaration of 'x' test/redeclared_variable.inx:2,0: info: Here is the first declaration of 'x'
 x : float = 1.0  x : float = 1.0
^ ^
 

2
test/semant/struct_access_primitive_type.golden
View File

@@ -1,4 +1,4 @@
test/struct_access_primitive_type.shd:3,0: error: Attempting to access a field on a primitive type 'int'. test/struct_access_primitive_type.inx:3,0: error: Attempting to access a field on a primitive type 'int'.
x.d = 4; x.d = 4;
^ ^
declaration: declaration:

2
test/semant/type_as_variable_name.golden
View File

@@ -1,4 +1,4 @@
test/type_as_variable_name.shd:2,0: error: Invalid variable name 'int' test/type_as_variable_name.inx:2,0: error: Invalid variable name 'int'
 int : float = 4.0  int : float = 4.0
^^^ ^^^
 

2
test/semant/undeclared_function.golden
View File

@@ -1,4 +1,4 @@
test/undeclared_function.shd:2,0: error: Attempt to call undeclared function 'foo'. test/undeclared_function.inx:2,0: error: Attempt to call undeclared function 'foo'.
 foo();  foo();
^^^ ^^^

2
test/semant/undeclared_symbol.golden
View File

@@ -1,4 +1,4 @@
test/undeclared_symbol.shd:2,10: error: Use of undeclared symbol 'f' test/undeclared_symbol.inx:2,10: error: Use of undeclared symbol 'f'
 b : int = f;  b : int = f;
^ ^
 

10
test/semant/unknown_overload.golden
View File

@@ -1,4 +1,4 @@
test/unknown_overload.shd:6,0: error: Procedure call did not match any of the possible overloads for 'foo' test/unknown_overload.inx:6,0: error: Procedure call did not match any of the possible overloads for 'foo'
 found:  found:
foo(v, v); foo(v, v);
^^^ ^^^
@@ -7,10 +7,10 @@
 foo(v, v);  foo(v, v);
^ ^
 Possible overloads:  Possible overloads:
 foo :: (v1 : float3, v2 : float3) { (test/unknown_overload.shd:1)  foo :: (v1 : float3, v2 : float3) { (test/unknown_overload.inx:1)
 foo :: (v1 : float2, v2 : float2, v3 : float2) { (test/unknown_overload.shd:2)  foo :: (v1 : float2, v2 : float2, v3 : float2) { (test/unknown_overload.inx:2)
test/unknown_overload.shd:6,4: error: Type mismatch. Expected float3 got float test/unknown_overload.inx:6,4: error: Type mismatch. Expected float3 got float
 found:  found:
foo(v, v); foo(v, v);
^ ^
@@ -20,7 +20,7 @@
got: got:
v : float = 2.0 v : float = 2.0
test/unknown_overload.shd:6,7: error: Type mismatch. Expected float3 got float test/unknown_overload.inx:6,7: error: Type mismatch. Expected float3 got float
 found:  found:
foo(v, v); foo(v, v);
^ ^

8
test/semant/wrong_argument_count.golden
View File

@@ -1,15 +1,15 @@
test/wrong_argument_count.shd:5,19: error: Use of undeclared symbol 'w' test/wrong_argument_count.inx:5,19: error: Use of undeclared symbol 'w'
 return x * y * z * w;  return x * y * z * w;
^ ^
test/wrong_argument_count.shd:9,0: error: Procedure call did not match any of the possible overloads for 'foo' test/wrong_argument_count.inx:9,0: error: Procedure call did not match any of the possible overloads for 'foo'
 found:  found:
foo(2.0, 3.0); foo(2.0, 3.0);
^^^ ^^^
 Possible overloads:  Possible overloads:
 foo :: (x : float, y : float, z : float) -> float { (test/wrong_argument_count.shd:1)  foo :: (x : float, y : float, z : float) -> float { (test/wrong_argument_count.inx:1)
 Not enough arguments: Wanted 3, got 2.  Not enough arguments: Wanted 3, got 2.
 foo :: (x : float, y : float, z : float, w : float) -> float { (test/wrong_argument_count.shd:4)  foo :: (x : float, y : float, z : float, w : float) -> float { (test/wrong_argument_count.inx:4)
 Not enough arguments: Wanted 4, got 2.  Not enough arguments: Wanted 4, got 2.

4
test/semant/wrong_multiply.golden
View File

@@ -1,4 +1,4 @@
test/wrong_multiply.shd:4,34: error: Type mismatch. Expected float got float2 test/wrong_multiply.inx:4,34: error: Type mismatch. Expected float got float2
 found:  found:
result : float4 = float4(1.0, foo * res, 0.0, 1.0); result : float4 = float4(1.0, foo * res, 0.0, 1.0);
^ ^
@@ -6,6 +6,6 @@
float float
got: got:
res : float2 = float2(2.0, 2.0); res : float2 = float2(2.0, 2.0)
 

6
test/semant/wrong_type_for_function.golden
View File

@@ -1,4 +1,4 @@
test/wrong_type_for_function.shd:11,17: error: Procedure call did not match any of the possible overloads for 'float4' test/wrong_type_for_function.inx:11,17: error: Procedure call did not match any of the possible overloads for 'float4'
 found:  found:
color : float4 = float4(y, 1.0, 1.0, 1.0); color : float4 = float4(y, 1.0, 1.0, 1.0);
^^^^^^ ^^^^^^
@@ -7,9 +7,9 @@
 color : float4 = float4(y, 1.0, 1.0, 1.0);  color : float4 = float4(y, 1.0, 1.0, 1.0);
^ ^
 Possible overloads:  Possible overloads:
 foreign float4 :: (float, float, float, float) -> float4; (test/wrong_type_for_function.shd:78)  foreign float4 :: (float, float, float, float) -> float4; (test/wrong_type_for_function.inx:78)
test/wrong_type_for_function.shd:11,24: error: Type mismatch. Expected float got float2 test/wrong_type_for_function.inx:11,24: error: Type mismatch. Expected float got float2
 found:  found:
color : float4 = float4(y, 1.0, 1.0, 1.0); color : float4 = float4(y, 1.0, 1.0, 1.0);
^ ^

60
test/semant_all.suite
View File

@@ -1,30 +1,30 @@
test/assign_arithmetic_expression.shd semant test/assign_arithmetic_expression.ink semant
test/basic_property_and_return_value.shd semant test/basic_property_and_return_value.ink semant
test/complicated_computation.shd semant test/complicated_computation.ink semant
test/constant_buffer.shd semant test/constant_buffer.ink semant
test/empty_struct.shd semant test/empty_struct.ink semant
test/empty_vertex_main.shd semant test/empty_vertex_main.ink semant
test/empty_vertex_main_with_position_parameter.shd semant test/empty_vertex_main_with_position_parameter.ink semant
test/field_assignment.shd semant test/field_assignment.ink semant
test/function_call.shd semant test/function_call.ink semant
test/function_call_out_of_order_declaration.shd semant test/function_call_out_of_order_declaration.ink semant
test/function_call_return.shd semant test/function_call_return.ink semant
test/functions_with_same_name.shd semant test/functions_with_same_name.ink semant
test/function_with_int_return.shd semant test/function_with_int_return.ink semant
test/multiple_functions.shd semant test/multiple_functions.ink semant
test/multiple_semicolons_everywhere.shd semant test/multiple_semicolons_everywhere.ink semant
test/pass_and_access_struct_fields_in_functions.shd semant test/pass_and_access_struct_fields_in_functions.ink semant
test/passthrough.shd semant test/passthrough.ink semant
test/property_rename.shd semant test/property_rename.ink semant
test/redeclared_variable.shd semant test/redeclared_variable.ink semant
test/simple_struct_access.shd semant test/simple_struct_access.ink semant
test/struct_access_primitive_type.shd semant test/struct_access_primitive_type.ink semant
test/struct_within_struct.shd semant test/struct_within_struct.ink semant
test/type_as_variable_name.shd semant test/type_as_variable_name.ink semant
test/undeclared_function.shd semant test/undeclared_function.ink semant
test/undeclared_symbol.shd semant test/undeclared_symbol.ink semant
test/unknown_overload.shd semant test/unknown_overload.ink semant
test/use_builtin_functions.shd semant test/use_builtin_functions.ink semant
test/wrong_argument_count.shd semant test/wrong_argument_count.ink semant
test/wrong_multiply.shd semant test/wrong_multiply.ink semant
test/wrong_type_for_function.shd semant test/wrong_type_for_function.ink semant

0
test/simple_float2_expressions.shd → test/simple_float2_expressions.ink
View File

0
test/simple_struct_access.shd → test/simple_struct_access.ink
View File

0
test/struct_access_primitive_type.shd → test/struct_access_primitive_type.ink
View File

0
test/struct_with_multiple_members.shd → test/struct_with_multiple_members.ink
View File

0
test/struct_within_struct.shd → test/struct_within_struct.ink
View File

0
test/texture_sample.shd → test/texture_sample.ink
View File

0
test/type_as_function_name.shd → test/type_as_function_name.ink
View File

0
test/type_as_variable_name.shd → test/type_as_variable_name.ink
View File

0
test/undeclared_function.shd → test/undeclared_function.ink
View File

0
test/undeclared_symbol.shd → test/undeclared_symbol.ink
View File

0
test/unknown_overload.shd → test/unknown_overload.ink
View File

0
test/use_builtin_functions.shd → test/use_builtin_functions.ink
View File

0
test/wrong_argument_count.shd → test/wrong_argument_count.ink
View File

0
test/wrong_multiply.shd → test/wrong_multiply.ink
View File

0
test/wrong_type_for_function.shd → test/wrong_type_for_function.ink
View File