TypeVar and virtual support in Symbol Resolver #99
@ -25,7 +25,6 @@ class virtual(Generic[T]):
|
|||||||
import device_db
|
import device_db
|
||||||
core_arguments = device_db.device_db["core"]["arguments"]
|
core_arguments = device_db.device_db["core"]["arguments"]
|
||||||
|
|
||||||
|
|
||||||
compiler = nac3artiq.NAC3(core_arguments["target"])
|
compiler = nac3artiq.NAC3(core_arguments["target"])
|
||||||
allow_registration = True
|
allow_registration = True
|
||||||
# Delay NAC3 analysis until all referenced variables are supposed to exist on the CPython side.
|
# Delay NAC3 analysis until all referenced variables are supposed to exist on the CPython side.
|
||||||
|
@ -13,7 +13,7 @@ use crate::{
|
|||||||
use crate::{location::Location, typecheck::typedef::TypeEnum};
|
use crate::{location::Location, typecheck::typedef::TypeEnum};
|
||||||
use inkwell::values::BasicValueEnum;
|
use inkwell::values::BasicValueEnum;
|
||||||
use itertools::{chain, izip};
|
use itertools::{chain, izip};
|
||||||
use nac3parser::ast::{Expr, StrRef};
|
use nac3parser::ast::{Constant::Str, Expr, StrRef};
|
||||||
use parking_lot::RwLock;
|
use parking_lot::RwLock;
|
||||||
|
|
||||||
#[derive(Clone, PartialEq, Debug)]
|
#[derive(Clone, PartialEq, Debug)]
|
||||||
@ -79,8 +79,7 @@ pub fn parse_type_annotation<T>(
|
|||||||
let list_id = ids[6];
|
let list_id = ids[6];
|
||||||
let tuple_id = ids[7];
|
let tuple_id = ids[7];
|
||||||
|
|
||||||
match &expr.node {
|
let name_handling = |id: &StrRef, unifier: &mut Unifier| {
|
||||||
Name { id, .. } => {
|
|
||||||
if *id == int32_id {
|
if *id == int32_id {
|
||||||
Ok(primitives.int32)
|
Ok(primitives.int32)
|
||||||
} else if *id == int64_id {
|
} else if *id == int64_id {
|
||||||
@ -129,9 +128,9 @@ pub fn parse_type_annotation<T>(
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
};
|
||||||
Subscript { value, slice, .. } => {
|
|
||||||
if let Name { id, .. } = &value.node {
|
let subscript_name_handle = |id: &StrRef, slice: &Expr<T>, unifier: &mut Unifier| {
|
||||||
if *id == virtual_id {
|
if *id == virtual_id {
|
||||||
let ty = parse_type_annotation(
|
let ty = parse_type_annotation(
|
||||||
resolver,
|
resolver,
|
||||||
@ -232,6 +231,16 @@ pub fn parse_type_annotation<T>(
|
|||||||
Err("Cannot use function name as type".into())
|
Err("Cannot use function name as type".into())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
match &expr.node {
|
||||||
|
Name { id, .. } => name_handling(id, unifier),
|
||||||
|
Constant { value: Str(id), .. } => name_handling(&id.clone().into(), unifier),
|
||||||
|
Subscript { value, slice, .. } => {
|
||||||
|
if let Name { id, .. } = &value.node {
|
||||||
|
subscript_name_handle(id, slice, unifier)
|
||||||
|
} else if let Constant { value: Str(id), .. } = &value.node {
|
||||||
|
subscript_name_handle(&id.clone().into(), slice, unifier)
|
||||||
} else {
|
} else {
|
||||||
Err("unsupported type expression".into())
|
Err("unsupported type expression".into())
|
||||||
}
|
}
|
||||||
|
@ -1,7 +1,7 @@
|
|||||||
use std::cell::RefCell;
|
use std::cell::RefCell;
|
||||||
|
|
||||||
use crate::typecheck::typedef::TypeVarMeta;
|
use crate::typecheck::typedef::TypeVarMeta;
|
||||||
|
use ast::Constant::Str;
|
||||||
use super::*;
|
use super::*;
|
||||||
|
|
||||||
#[derive(Clone, Debug)]
|
#[derive(Clone, Debug)]
|
||||||
@ -49,10 +49,9 @@ pub fn parse_ast_to_type_annotation_kinds<T>(
|
|||||||
primitives: &PrimitiveStore,
|
primitives: &PrimitiveStore,
|
||||||
expr: &ast::Expr<T>,
|
expr: &ast::Expr<T>,
|
||||||
// the key stores the type_var of this topleveldef::class, we only need this field here
|
// the key stores the type_var of this topleveldef::class, we only need this field here
|
||||||
mut locked: HashMap<DefinitionId, Vec<Type>>,
|
locked: HashMap<DefinitionId, Vec<Type>>,
|
||||||
) -> Result<TypeAnnotation, String> {
|
) -> Result<TypeAnnotation, String> {
|
||||||
match &expr.node {
|
let name_handle = |id: &StrRef, unifier: &mut Unifier, locked: HashMap<DefinitionId, Vec<Type>>| {
|
||||||
ast::ExprKind::Name { id, .. } => {
|
|
||||||
if id == &"int32".into() {
|
if id == &"int32".into() {
|
||||||
Ok(TypeAnnotation::Primitive(primitives.int32))
|
Ok(TypeAnnotation::Primitive(primitives.int32))
|
||||||
} else if id == &"int64".into() {
|
} else if id == &"int64".into() {
|
||||||
@ -95,74 +94,10 @@ pub fn parse_ast_to_type_annotation_kinds<T>(
|
|||||||
} else {
|
} else {
|
||||||
Err("name cannot be parsed as a type annotation".into())
|
Err("name cannot be parsed as a type annotation".into())
|
||||||
}
|
}
|
||||||
}
|
};
|
||||||
|
|
||||||
// virtual
|
let class_name_handle =
|
||||||
ast::ExprKind::Subscript { value, slice, .. }
|
|id: &StrRef, slice: &ast::Expr<T>, unifier: &mut Unifier, mut locked: HashMap<DefinitionId, Vec<Type>>| {
|
||||||
if {
|
|
||||||
matches!(&value.node, ast::ExprKind::Name { id, .. } if id == &"virtual".into())
|
|
||||||
} =>
|
|
||||||
{
|
|
||||||
let def = parse_ast_to_type_annotation_kinds(
|
|
||||||
resolver,
|
|
||||||
top_level_defs,
|
|
||||||
unifier,
|
|
||||||
primitives,
|
|
||||||
slice.as_ref(),
|
|
||||||
locked,
|
|
||||||
)?;
|
|
||||||
if !matches!(def, TypeAnnotation::CustomClass { .. }) {
|
|
||||||
unreachable!("must be concretized custom class kind in the virtual")
|
|
||||||
}
|
|
||||||
Ok(TypeAnnotation::Virtual(def.into()))
|
|
||||||
}
|
|
||||||
|
|
||||||
// list
|
|
||||||
ast::ExprKind::Subscript { value, slice, .. }
|
|
||||||
if {
|
|
||||||
matches!(&value.node, ast::ExprKind::Name { id, .. } if id == &"list".into())
|
|
||||||
} =>
|
|
||||||
{
|
|
||||||
let def_ann = parse_ast_to_type_annotation_kinds(
|
|
||||||
resolver,
|
|
||||||
top_level_defs,
|
|
||||||
unifier,
|
|
||||||
primitives,
|
|
||||||
slice.as_ref(),
|
|
||||||
locked,
|
|
||||||
)?;
|
|
||||||
Ok(TypeAnnotation::List(def_ann.into()))
|
|
||||||
}
|
|
||||||
|
|
||||||
// tuple
|
|
||||||
ast::ExprKind::Subscript { value, slice, .. }
|
|
||||||
if {
|
|
||||||
matches!(&value.node, ast::ExprKind::Name { id, .. } if id == &"tuple".into())
|
|
||||||
} =>
|
|
||||||
{
|
|
||||||
if let ast::ExprKind::Tuple { elts, .. } = &slice.node {
|
|
||||||
let type_annotations = elts
|
|
||||||
.iter()
|
|
||||||
.map(|e| {
|
|
||||||
parse_ast_to_type_annotation_kinds(
|
|
||||||
resolver,
|
|
||||||
top_level_defs,
|
|
||||||
unifier,
|
|
||||||
primitives,
|
|
||||||
e,
|
|
||||||
locked.clone(),
|
|
||||||
)
|
|
||||||
})
|
|
||||||
.collect::<Result<Vec<_>, _>>()?;
|
|
||||||
Ok(TypeAnnotation::Tuple(type_annotations))
|
|
||||||
} else {
|
|
||||||
Err("Expect multiple elements for tuple".into())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// custom class
|
|
||||||
ast::ExprKind::Subscript { value, slice, .. } => {
|
|
||||||
if let ast::ExprKind::Name { id, .. } = &value.node {
|
|
||||||
if vec!["virtual".into(), "Generic".into(), "list".into(), "tuple".into()]
|
if vec!["virtual".into(), "Generic".into(), "list".into(), "tuple".into()]
|
||||||
.contains(id)
|
.contains(id)
|
||||||
{
|
{
|
||||||
@ -188,7 +123,7 @@ pub fn parse_ast_to_type_annotation_kinds<T>(
|
|||||||
let params_ast = if let ast::ExprKind::Tuple { elts, .. } = &slice.node {
|
let params_ast = if let ast::ExprKind::Tuple { elts, .. } = &slice.node {
|
||||||
elts.iter().collect_vec()
|
elts.iter().collect_vec()
|
||||||
} else {
|
} else {
|
||||||
vec![slice.as_ref()]
|
vec![slice]
|
||||||
};
|
};
|
||||||
if type_vars.len() != params_ast.len() {
|
if type_vars.len() != params_ast.len() {
|
||||||
return Err(format!(
|
return Err(format!(
|
||||||
@ -213,7 +148,6 @@ pub fn parse_ast_to_type_annotation_kinds<T>(
|
|||||||
)
|
)
|
||||||
})
|
})
|
||||||
.collect::<Result<Vec<_>, _>>()?;
|
.collect::<Result<Vec<_>, _>>()?;
|
||||||
|
|
||||||
// make sure the result do not contain any type vars
|
// make sure the result do not contain any type vars
|
||||||
let no_type_var = result
|
let no_type_var = result
|
||||||
.iter()
|
.iter()
|
||||||
@ -226,8 +160,83 @@ pub fn parse_ast_to_type_annotation_kinds<T>(
|
|||||||
.into());
|
.into());
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
Ok(TypeAnnotation::CustomClass { id: obj_id, params: param_type_infos })
|
Ok(TypeAnnotation::CustomClass { id: obj_id, params: param_type_infos })
|
||||||
|
};
|
||||||
|
match &expr.node {
|
||||||
|
ast::ExprKind::Name { id, .. } => name_handle(id, unifier, locked),
|
||||||
|
ast::ExprKind::Constant { value: Str(id), .. } => name_handle(&id.clone().into(), unifier, locked),
|
||||||
|
// virtual
|
||||||
|
ast::ExprKind::Subscript { value, slice, .. }
|
||||||
|
if {
|
||||||
|
matches!(&value.node, ast::ExprKind::Name { id, .. } if id == &"virtual".into()) ||
|
||||||
|
matches!(&value.node, ast::ExprKind::Constant { value: Str(id), .. } if id == "virtual")
|
||||||
|
} =>
|
||||||
|
{
|
||||||
|
let def = parse_ast_to_type_annotation_kinds(
|
||||||
|
resolver,
|
||||||
|
top_level_defs,
|
||||||
|
unifier,
|
||||||
|
primitives,
|
||||||
|
slice.as_ref(),
|
||||||
|
locked,
|
||||||
|
)?;
|
||||||
|
if !matches!(def, TypeAnnotation::CustomClass { .. }) {
|
||||||
|
unreachable!("must be concretized custom class kind in the virtual")
|
||||||
|
}
|
||||||
|
Ok(TypeAnnotation::Virtual(def.into()))
|
||||||
|
}
|
||||||
|
|
||||||
|
// list
|
||||||
|
ast::ExprKind::Subscript { value, slice, .. }
|
||||||
|
if {
|
||||||
|
matches!(&value.node, ast::ExprKind::Name { id, .. } if id == &"list".into()) ||
|
||||||
|
matches!(&value.node, ast::ExprKind::Constant { value: Str(id), .. } if id == "list")
|
||||||
|
} =>
|
||||||
|
{
|
||||||
|
let def_ann = parse_ast_to_type_annotation_kinds(
|
||||||
|
resolver,
|
||||||
|
top_level_defs,
|
||||||
|
unifier,
|
||||||
|
primitives,
|
||||||
|
slice.as_ref(),
|
||||||
|
locked,
|
||||||
|
)?;
|
||||||
|
Ok(TypeAnnotation::List(def_ann.into()))
|
||||||
|
}
|
||||||
|
|
||||||
|
// tuple
|
||||||
|
ast::ExprKind::Subscript { value, slice, .. }
|
||||||
|
if {
|
||||||
|
matches!(&value.node, ast::ExprKind::Name { id, .. } if id == &"tuple".into()) ||
|
||||||
|
matches!(&value.node, ast::ExprKind::Constant { value: Str(id), .. } if id == "tuple")
|
||||||
|
} =>
|
||||||
|
{
|
||||||
|
if let ast::ExprKind::Tuple { elts, .. } = &slice.node {
|
||||||
|
let type_annotations = elts
|
||||||
|
.iter()
|
||||||
|
.map(|e| {
|
||||||
|
parse_ast_to_type_annotation_kinds(
|
||||||
|
resolver,
|
||||||
|
top_level_defs,
|
||||||
|
unifier,
|
||||||
|
primitives,
|
||||||
|
e,
|
||||||
|
locked.clone(),
|
||||||
|
)
|
||||||
|
})
|
||||||
|
.collect::<Result<Vec<_>, _>>()?;
|
||||||
|
Ok(TypeAnnotation::Tuple(type_annotations))
|
||||||
|
} else {
|
||||||
|
Err("Expect multiple elements for tuple".into())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// custom class
|
||||||
|
ast::ExprKind::Subscript { value, slice, .. } => {
|
||||||
|
if let ast::ExprKind::Name { id, .. } = &value.node {
|
||||||
|
class_name_handle(id, slice, unifier, locked)
|
||||||
|
} else if let ast::ExprKind::Constant { value: Str(id), .. } = &value.node {
|
||||||
|
class_name_handle(&id.clone().into(), slice, unifier, locked)
|
||||||
} else {
|
} else {
|
||||||
Err("unsupported expression type for class name".into())
|
Err("unsupported expression type for class name".into())
|
||||||
}
|
}
|
||||||
@ -368,13 +377,7 @@ pub fn get_type_from_type_annotation_kinds(
|
|||||||
/// But note that here we do not make a duplication of `T`, `V`, we direclty
|
/// But note that here we do not make a duplication of `T`, `V`, we direclty
|
||||||
/// use them as they are in the TopLevelDef::Class since those in the
|
/// use them as they are in the TopLevelDef::Class since those in the
|
||||||
/// TopLevelDef::Class.type_vars will be substitute later when seeing applications/instantiations
|
/// TopLevelDef::Class.type_vars will be substitute later when seeing applications/instantiations
|
||||||
/// the Type of their fields and methods will also be subst when application/instantiation \
|
/// the Type of their fields and methods will also be subst when application/instantiation
|
||||||
/// \
|
|
||||||
/// Note this implicit self type is different with seeing `A[T, V]` explicitly outside
|
|
||||||
/// the class def ast body, where it is a new instantiation of the generic class `A`,
|
|
||||||
/// but equivalent to seeing `A[T, V]` inside the class def body ast, where although we
|
|
||||||
/// create copies of `T` and `V`, we will find them out as occured type vars in the analyze_class()
|
|
||||||
/// and unify them with the class generic `T`, `V`
|
|
||||||
pub fn make_self_type_annotation(type_vars: &[Type], object_id: DefinitionId) -> TypeAnnotation {
|
pub fn make_self_type_annotation(type_vars: &[Type], object_id: DefinitionId) -> TypeAnnotation {
|
||||||
TypeAnnotation::CustomClass {
|
TypeAnnotation::CustomClass {
|
||||||
id: object_id,
|
id: object_id,
|
||||||
|
Loading…
Reference in New Issue
Block a user