nac3core: parse type annotation python forwardref handling

nac3artiq/demo/min_artiq.py

@@ -25,7 +25,6 @@ class virtual(Generic[T]):
 import device_db
 core_arguments = device_db.device_db["core"]["arguments"]
 
-
 compiler = nac3artiq.NAC3(core_arguments["target"])
 allow_registration = True
 # Delay NAC3 analysis until all referenced variables are supposed to exist on the CPython side.

nac3core/src/symbol_resolver.rs

@@ -13,7 +13,7 @@ use crate::{
 use crate::{location::Location, typecheck::typedef::TypeEnum};
 use inkwell::values::BasicValueEnum;
 use itertools::{chain, izip};
-use nac3parser::ast::{Expr, StrRef};
+use nac3parser::ast::{Constant::Str, Expr, StrRef};
 use parking_lot::RwLock;
 
 #[derive(Clone, PartialEq, Debug)]
@@ -79,8 +79,7 @@ pub fn parse_type_annotation<T>(
     let list_id = ids[6];
     let tuple_id = ids[7];
 
-    match &expr.node {
+    let name_handling = |id: &StrRef, unifier: &mut Unifier| {
-        Name { id, .. } => {
         if *id == int32_id {
             Ok(primitives.int32)
         } 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 {
             let ty = parse_type_annotation(
                 resolver,
@@ -232,6 +231,16 @@ pub fn parse_type_annotation<T>(
                 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 {
                 Err("unsupported type expression".into())
             }

nac3core/src/toplevel/type_annotation.rs

@@ -1,7 +1,7 @@
 use std::cell::RefCell;
 
 use crate::typecheck::typedef::TypeVarMeta;
-
+use ast::Constant::Str;
 use super::*;
 
 #[derive(Clone, Debug)]
@@ -49,10 +49,9 @@ pub fn parse_ast_to_type_annotation_kinds<T>(
     primitives: &PrimitiveStore,
     expr: &ast::Expr<T>,
     // 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> {
-    match &expr.node {
+    let name_handle = |id: &StrRef, unifier: &mut Unifier, locked: HashMap<DefinitionId, Vec<Type>>| {
-        ast::ExprKind::Name { id, .. } => {
         if id == &"int32".into() {
             Ok(TypeAnnotation::Primitive(primitives.int32))
         } else if id == &"int64".into() {
@@ -95,74 +94,10 @@ pub fn parse_ast_to_type_annotation_kinds<T>(
         } else {
             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()]
                 .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 {
                 elts.iter().collect_vec()
             } else {
-                        vec![slice.as_ref()]
+                vec![slice]
             };
             if type_vars.len() != params_ast.len() {
                 return Err(format!(
@@ -213,7 +148,6 @@ pub fn parse_ast_to_type_annotation_kinds<T>(
                     )
                 })
                 .collect::<Result<Vec<_>, _>>()?;
-
             // make sure the result do not contain any type vars
             let no_type_var = result
                 .iter()
@@ -226,8 +160,83 @@ pub fn parse_ast_to_type_annotation_kinds<T>(
                     .into());
             }
         };
-
         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 {
                 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
 /// 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
-/// 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 {
     TypeAnnotation::CustomClass {
         id: object_id,