Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

fix(compiler): unable to create array of valid heterogeneous values #3885

Merged
merged 5 commits into from
Aug 18, 2023
Merged

fix(compiler): unable to create array of valid heterogeneous values #3885

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
5 commits
Select commit Hold shift + click to select a range
eb50f10
fix
MarkMcCulloh Aug 18, 2023
8223a42
more test cases
MarkMcCulloh Aug 18, 2023
848fbd6
fix example
MarkMcCulloh Aug 18, 2023
fa5ffaa
do the same cleanup for other containers
MarkMcCulloh Aug 18, 2023
927d245
update
MarkMcCulloh Aug 18, 2023
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
24 changes: 23 additions & 1 deletion examples/tests/valid/std_containers.w
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -40,4 +40,26 @@ let immutMap = mutMap.copy();
assert(sMap.get("one") == 1);
assert(sMap.size() == 2);
assert(immutMap.size() == 3);
assert(nestedMap.get("a").get("b").get("c") == "hello");
assert(nestedMap.get("a").get("b").get("c") == "hello");

class Animal {}
class Cat extends Animal {}
class Dog extends Animal {}

let heterogeneousArray = Array<Animal>[
new Cat() as "C1",
new Dog() as "D1",
];
let heterogeneousDoubleArray = Array<Array<Animal>>[
[new Cat() as "C2"],
Array<Animal>[new Cat() as "C3", new Dog() as "D2"],
[new Animal() as "A1"],
];
let heterogeneousSet = Set<Animal>{
new Cat() as "C4",
new Dog() as "D3",
};
let heterogeneousMap = Map<Animal>{
"cat" => new Cat() as "C5",
"dog" => new Dog() as "D4",
};
204 changes: 97 additions & 107 deletions libs/wingc/src/type_check.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2109,43 +2109,114 @@ impl<'a> TypeChecker<'a> {
}
ExprKind::ArrayLiteral { type_, items } => {
// Infer type based on either the explicit type or the value in one of the items
let container_type = if let Some(type_) = type_ {
self.resolve_type_annotation(type_, env)
let (container_type, mut element_type) = if let Some(type_) = type_ {
let container_type = self.resolve_type_annotation(type_, env);
let element_type = match *container_type {
Type::Array(t) | Type::MutArray(t) => t,
_ => {
self.spanned_error(
&type_.span,
format!("Expected \"Array\" or \"MutArray\", found \"{container_type}\""),
);
self.types.error()
}
};
(container_type, element_type)
} else if self.in_json > 0 {
let json_data = JsonData {
expression_id: exp.id,
kind: JsonDataKind::List(vec![]),
};
let inner_type = self.types.add_type(Type::Json(Some(json_data)));
(self.types.add_type(Type::Array(inner_type)), inner_type)
} else {
if self.in_json > 0 {
let json_data = JsonData {
expression_id: exp.id,
kind: JsonDataKind::List(vec![]),
};
let inner_type = self.types.add_type(Type::Json(Some(json_data)));
self.types.add_type(Type::Array(inner_type))
} else {
let inner_type = self.types.make_inference();
self.types.add_type(Type::Array(inner_type))
}
};

let mut element_type = match *container_type {
Type::Array(t) => t,
Type::MutArray(t) => t,
_ => {
self.spanned_error(exp, format!("Expected \"Array\" type, found \"{}\"", container_type));
self.types.error()
}
let inner_type = self.types.make_inference();
(self.types.add_type(Type::Array(inner_type)), inner_type)
};

// Verify all types are the same as the inferred type
for v in items.iter() {
let (t, _) = self.type_check_exp(v, env);
for item in items {
let (t, _) = self.type_check_exp(item, env);

// Augment the json list data with the new element type
if let Type::Json(Some(JsonData { ref mut kind, .. })) = &mut *element_type {
if let JsonDataKind::List(ref mut json_list) = kind {
json_list.push(SpannedTypeInfo {
type_: t,
span: v.span(),
span: item.span(),
});
}
}
element_type = self.check_json_serializable_or_validate_type(t, element_type, v);

if self.in_json == 0 {
// If we're not in a Json literal, validate the type of each element
self.validate_type(t, element_type, item);
element_type = self.types.maybe_unwrap_inference(element_type);
} else if self.is_in_mut_json && !t.is_json_legal_value() {
// if we're in a MutJson literal, we only need to check that each field is legal json
self.spanned_error(
item,
format!("Expected a valid Json value (https://www.json.org/json-en.html), but got \"{t}\""),
);
}
}

(container_type, env.phase)
}
ExprKind::MapLiteral { fields, type_ } => {
// Infer type based on either the explicit type or the value in one of the fields
let (container_type, mut element_type) = if let Some(type_) = type_ {
let container_type = self.resolve_type_annotation(type_, env);
let element_type = match *container_type {
Type::Map(t) | Type::MutMap(t) => t,
_ => {
self.spanned_error(
&type_.span,
format!("Expected \"Map\" or \"MutMap\", found \"{container_type}\""),
);
self.types.error()
}
};
(container_type, element_type)
} else {
let inner_type = self.types.make_inference();
(self.types.add_type(Type::Map(inner_type)), inner_type)
};

// Verify all types are the same as the inferred type
for field in fields.values() {
let (t, _) = self.type_check_exp(field, env);
self.validate_type(t, element_type, field);
element_type = self.types.maybe_unwrap_inference(element_type);
}

(container_type, env.phase)
}
ExprKind::SetLiteral { type_, items } => {
// Infer type based on either the explicit type or the value in one of the items
let (container_type, mut element_type) = if let Some(type_) = type_ {
let container_type = self.resolve_type_annotation(type_, env);
let element_type = match *container_type {
Type::Set(t) | Type::MutSet(t) => t,
_ => {
self.spanned_error(
&type_.span,
format!("Expected \"Set\" or \"MutSet\", found \"{container_type}\""),
);
self.types.error()
}
};
(container_type, element_type)
} else {
let inner_type = self.types.make_inference();
(self.types.add_type(Type::Set(inner_type)), inner_type)
};

// Verify all types are the same as the inferred type
for item in items {
let (t, _) = self.type_check_exp(item, env);
self.validate_type(t, element_type, item);
element_type = self.types.maybe_unwrap_inference(element_type);
}

(container_type, env.phase)
Expand Down Expand Up @@ -2285,58 +2356,6 @@ impl<'a> TypeChecker<'a> {
env.phase,
)
}
ExprKind::MapLiteral { fields, type_ } => {
// Infer type based on either the explicit type or the value in one of the fields
let container_type = if let Some(type_) = type_ {
self.resolve_type_annotation(type_, env)
} else {
let inner_type = self.types.make_inference();
self.types.add_type(Type::Map(inner_type))
};

let mut value_type = match *container_type {
Type::Map(t) => t,
Type::MutMap(t) => t,
_ => {
self.spanned_error(exp, format!("Expected \"Map\" type, found \"{}\"", container_type));
self.types.error()
}
};

// Verify all types are the same as the inferred type
for (_, v) in fields.iter() {
let (t, _) = self.type_check_exp(v, env);
value_type = self.validate_type(t, value_type, v);
}

(container_type, env.phase)
}
ExprKind::SetLiteral { type_, items } => {
// Infer type based on either the explicit type or the value in one of the items
let container_type = if let Some(type_) = type_ {
self.resolve_type_annotation(type_, env)
} else {
let inferred = self.types.make_inference();
self.types.add_type(Type::Set(inferred))
};

let mut element_type = match *container_type {
Type::Set(t) => t,
Type::MutSet(t) => t,
_ => {
self.spanned_error(exp, format!("Expected \"Set\" type, found \"{}\"", container_type));
self.types.error()
}
};

// Verify all types are the same as the inferred type
for v in items.iter() {
let (t, _) = self.type_check_exp(v, env);
element_type = self.validate_type(t, element_type, v);
}

(container_type, env.phase)
}
ExprKind::FunctionClosure(func_def) => self.type_check_closure(func_def, env),
ExprKind::CompilerDebugPanic => {
// Handle the debug panic expression (during type-checking)
Expand Down Expand Up @@ -2565,35 +2584,6 @@ impl<'a> TypeChecker<'a> {
}
}

fn check_json_serializable_or_validate_type(
&mut self,
actual_type: TypeRef,
expected_type: TypeRef,
exp: &Expr,
) -> TypeRef {
// Skip validate if in Json
if self.in_json == 0 {
return self.validate_type(actual_type, expected_type, exp);
}

if self.is_in_mut_json && !actual_type.is_json_legal_value() {
self.spanned_error(
exp,
format!(
"Expected a valid Json value (https://www.json.org/json-en.html), but got \"{}\"",
actual_type
),
);
return self.types.error();
}

if expected_type.is_json() {
expected_type
} else {
actual_type
}
}

/// Validate that the given type is a subtype (or same) as the expected type. If not, add an error
/// to the diagnostics.
///
Expand Down
34 changes: 10 additions & 24 deletions tools/hangar/__snapshots__/invalid.ts.snap
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -488,11 +488,11 @@ error: Expected type to be \\"num\\", but got \\"str\\" instead
| ^^^ Expected type to be \\"num\\", but got \\"str\\" instead


error: Expected \\"Set\\" type, found \\"Array<num>\\"
error: Expected \\"Set\\" or \\"MutSet\\", found \\"Array<num>\\"
--> ../../../examples/tests/invalid/container_types.w:3:12
|
3 | let arr2 = Array<num> {1, 2, 3};
| ^^^^^^^^^^^^^^^^^^^^ Expected \\"Set\\" type, found \\"Array<num>\\"
| ^^^^^^^^^^ Expected \\"Set\\" or \\"MutSet\\", found \\"Array<num>\\"


error: Expected type to be \\"Array<num>\\", but got \\"Array<str>\\" instead
Expand Down Expand Up @@ -551,18 +551,11 @@ error: Expected type to be \\"num\\", but got \\"str\\" instead
| ^^^ Expected type to be \\"num\\", but got \\"str\\" instead


error: Expected \\"Array\\" type, found \\"Set<num>\\"
error: Expected \\"Array\\" or \\"MutArray\\", found \\"Set<num>\\"
--> ../../../examples/tests/invalid/container_types.w:21:10
|
21 | let s2 = Set<num> [1, \\"2\\", 3];
| ^^^^^^^^^^^^^^^^^^^^ Expected \\"Array\\" type, found \\"Set<num>\\"


error: Expected type to be \\"num\\", but got \\"str\\" instead
--> ../../../examples/tests/invalid/container_types.w:21:23
|
21 | let s2 = Set<num> [1, \\"2\\", 3];
| ^^^ Expected type to be \\"num\\", but got \\"str\\" instead
| ^^^^^^^^ Expected \\"Array\\" or \\"MutArray\\", found \\"Set<num>\\"


error: Expected type to be \\"num\\", but got \\"str\\" instead
Expand Down Expand Up @@ -1537,11 +1530,11 @@ exports[`mut_container_types.w 1`] = `
| ^^^ Expected type to be \\"num\\", but got \\"str\\" instead


error: Expected \\"Set\\" type, found \\"MutArray<num>\\"
error: Expected \\"Set\\" or \\"MutSet\\", found \\"MutArray<num>\\"
--> ../../../examples/tests/invalid/mut_container_types.w:3:12
|
3 | let arr2 = MutArray<num>{1, 2, 3};
| ^^^^^^^^^^^^^^^^^^^^^^ Expected \\"Set\\" type, found \\"MutArray<num>\\"
| ^^^^^^^^^^^^^ Expected \\"Set\\" or \\"MutSet\\", found \\"MutArray<num>\\"


error: Expected type to be \\"MutArray<num>\\", but got \\"Array<num>\\" instead
Expand Down Expand Up @@ -1572,18 +1565,11 @@ error: Expected type to be \\"num\\", but got \\"str\\" instead
| ^^^ Expected type to be \\"num\\", but got \\"str\\" instead


error: Expected \\"Array\\" type, found \\"MutSet<num>\\"
error: Expected \\"Array\\" or \\"MutArray\\", found \\"MutSet<num>\\"
--> ../../../examples/tests/invalid/mut_container_types.w:11:10
|
11 | let s2 = MutSet<num>[1, \\"2\\", 3];
| ^^^^^^^^^^^^^^^^^^^^^^ Expected \\"Array\\" type, found \\"MutSet<num>\\"


error: Expected type to be \\"num\\", but got \\"str\\" instead
--> ../../../examples/tests/invalid/mut_container_types.w:11:25
|
11 | let s2 = MutSet<num>[1, \\"2\\", 3];
| ^^^ Expected type to be \\"num\\", but got \\"str\\" instead
MarkMcCulloh marked this conversation as resolved.
Show resolved Hide resolved
| ^^^^^^^^^^^ Expected \\"Array\\" or \\"MutArray\\", found \\"MutSet<num>\\"


error: Expected type to be \\"MutSet<num>\\", but got \\"Set<num>\\" instead
Expand Down Expand Up @@ -1614,11 +1600,11 @@ error: Expected type to be \\"num\\", but got \\"str\\" instead
| ^^^^^^^ Expected type to be \\"num\\", but got \\"str\\" instead


error: Expected \\"Array\\" type, found \\"MutMap<str>\\"
error: Expected \\"Array\\" or \\"MutArray\\", found \\"MutMap<str>\\"
--> ../../../examples/tests/invalid/mut_container_types.w:20:10
|
20 | let m2 = MutMap<str>[\\"hello\\", \\"world\\"];
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Expected \\"Array\\" type, found \\"MutMap<str>\\"
| ^^^^^^^^^^^ Expected \\"Array\\" or \\"MutArray\\", found \\"MutMap<str>\\"


error: Expected type to be \\"MutMap<num>\\", but got \\"Map<str>\\" instead
Expand Down
Loading