roc-lang/roc
1
1
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2024-09-21 15:59:20 +03:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #1302 from rtfeldman/constrain_expr2_var

Browse Source 
Constrain Expr2::Var
This commit is contained in:
Richard Feldman 2021-05-14 00:37:42 -04:00 committed by GitHub
commit 0ff7c98def
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 76 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
editor/src/lang/constrain.rs
View File

@ -21,7 +21,7 @@ use roc_types::{
pub enum Constraint<'a> {
Eq(Type2, Expected<Type2>, Category, Region),
// Store(Type, Variable, &'static str, u32),
// Lookup(Symbol, Expected<Type>, Region),
Lookup(Symbol, Expected<Type2>, Region),
// Pattern(Region, PatternCategory, Type, PExpected<Type>),
And(BumpVec<'a, Constraint<'a>>),
Let(&'a LetConstraint<'a>),
@ -52,6 +52,7 @@ pub fn constrain_expr<'a>(
Expr2::SmallStr(_) => Eq(str_type(env.pool), expected, Category::Str, region),
Expr2::Blank => True,
Expr2::EmptyRecord => constrain_empty_record(expected, region),
Expr2::Var(symbol) => Lookup(*symbol, expected, region),
Expr2::SmallInt { var, .. } => {
let mut flex_vars = BumpVec::with_capacity_in(1, arena);

144
editor/src/lang/solve.rs
View File

@ -1,7 +1,7 @@
#![allow(clippy::all)]
#![allow(dead_code)]
use crate::lang::constrain::Constraint::{self, *};
use crate::lang::pool::Pool;
use crate::lang::pool::{Pool, ShallowClone};
use crate::lang::types::Type2;
use bumpalo::Bump;
use roc_can::expected::{Expected, PExpected};
@ -270,75 +270,79 @@ fn solve<'a>(
// }
// }
// }
// Lookup(symbol, expectation, region) => {
// match env.vars_by_symbol.get(&symbol) {
// Some(var) => {
// // Deep copy the vars associated with this symbol before unifying them.
// // Otherwise, suppose we have this:
// //
// // identity = \a -> a
// //
// // x = identity 5
// //
// // When we call (identity 5), it's important that we not unify
// // on identity's original vars. If we do, the type of `identity` will be
// // mutated to be `Int -> Int` instead of `a -> `, which would be incorrect;
// // the type of `identity` is more general than that!
// //
// // Instead, we want to unify on a *copy* of its vars. If the copy unifies
// // successfully (in this case, to `Int -> Int`), we can use that to
// // infer the type of this lookup (in this case, `Int`) without ever
// // having mutated the original.
// //
// // If this Lookup is targeting a value in another module,
// // then we copy from that module's Subs into our own. If the value
// // is being looked up in this module, then we use our Subs as both
// // the source and destination.
// let actual = deep_copy_var(subs, rank, pools, *var);
// let expected = type_to_var(
// subs,
// rank,
// pools,
// cached_aliases,
// expectation.get_type_ref(),
// );
// match unify(subs, actual, expected) {
// Success(vars) => {
// introduce(subs, rank, pools, &vars);
//
// state
// }
//
// Failure(vars, actual_type, expected_type) => {
// introduce(subs, rank, pools, &vars);
//
// let problem = TypeError::BadExpr(
// *region,
// Category::Lookup(*symbol),
// actual_type,
// expectation.clone().replace(expected_type),
// );
//
// problems.push(problem);
//
// state
// }
// BadType(vars, problem) => {
// introduce(subs, rank, pools, &vars);
//
// problems.push(TypeError::BadType(problem));
//
// state
// }
// }
// }
// None => {
// problems.push(TypeError::UnexposedLookup(*symbol));
//
// state
// }
// }
// }
Lookup(symbol, expectation, region) => {
match env.vars_by_symbol.get(&symbol) {
Some(var) => {
// Deep copy the vars associated with this symbol before unifying them.
// Otherwise, suppose we have this:
//
// identity = \a -> a
//
// x = identity 5
//
// When we call (identity 5), it's important that we not unify
// on identity's original vars. If we do, the type of `identity` will be
// mutated to be `Int -> Int` instead of `a -> `, which would be incorrect;
// the type of `identity` is more general than that!
//
// Instead, we want to unify on a *copy* of its vars. If the copy unifies
// successfully (in this case, to `Int -> Int`), we can use that to
// infer the type of this lookup (in this case, `Int`) without ever
// having mutated the original.
//
// If this Lookup is targeting a value in another module,
// then we copy from that module's Subs into our own. If the value
// is being looked up in this module, then we use our Subs as both
// the source and destination.
let actual = deep_copy_var(subs, rank, pools, *var);
let expected = type_to_var(
arena,
mempool,
subs,
rank,
pools,
cached_aliases,
expectation.get_type_ref(),
);
match unify(subs, actual, expected) {
Success(vars) => {
introduce(subs, rank, pools, &vars);
state
}
Failure(vars, actual_type, expected_type) => {
introduce(subs, rank, pools, &vars);
let problem = TypeError::BadExpr(
*region,
Category::Lookup(*symbol),
actual_type,
expectation.shallow_clone().replace(expected_type),
);
problems.push(problem);
state
}
BadType(vars, problem) => {
introduce(subs, rank, pools, &vars);
problems.push(TypeError::BadType(problem));
state
}
}
}
None => {
problems.push(TypeError::UnexposedLookup(*symbol));
state
}
}
}
And(sub_constraints) => {
let mut state = state;