feat: codeframe report

.github/workflows/test.yml

@@ -11,7 +11,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rust-lang/[email protected]
         with:
-          toolchain: "1.72.1"
+          toolchain: "1.80.1"
       - run: cargo test
 
   # # Check formatting with rustfmt

.vscode/settings.json

@@ -153,6 +153,8 @@
     "clippy::verbose_file_reads",
   ],
   "cSpell.words": [
-    "kore"
+    "kore",
+    "renderable",
+    "stdext"
   ],
 }

analyze/docs/architecture.d2

@@ -0,0 +1,42 @@
+semantic_analysis: Semantic Analysis
+semantic_analysis.shape: oval
+
+input: Input {
+  raw: Raw AST
+  context: Context
+}
+
+output: Output {
+  typed: Typed AST
+  types: Types
+}
+
+infer: Type Inference {
+  infer_weak: Weak Inference
+  infer_weak.shape: oval
+  infer_strong: Strong Inference
+  infer_strong.shape: oval
+  weak_output: Weak Output
+  strong_output: Strong Output
+
+  into_typed: Resolve Types
+  into_typed.shape: oval
+  canonicalize: Canonicalize
+  canonicalize.shape: oval
+
+  infer_weak -> weak_output
+  weak_output -> infer_strong
+  infer_strong -> infer_strong: incremental
+  infer_strong -> strong_output
+  strong_output -> into_typed
+  strong_output -> canonicalize
+}
+
+input.raw -> infer.infer_weak
+input.raw -> infer.into_typed
+input.context -> infer.infer_strong
+input.context -> infer.into_typed
+input.context -> infer.canonicalize
+infer.into_typed -> output.typed
+infer.canonicalize -> output.types
+output.typed -> semantic_analysis

analyze/src/error.rs

@@ -1,6 +1,10 @@
-use lang::{ast, types::Kind, CanonicalId};
+use lang::{
+    ast,
+    types::{self, Kind},
+    CanonicalId,
+};
 
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum Error {
     /* inference */
     NotInferrable(
@@ -17,6 +21,8 @@ pub enum Error {
     VariantNotFound(
         // id of the enum declaration
         CanonicalId,
+        // names of the valid variants
+        Vec<String>,
         // name of the expected variant
         String,
     ),
@@ -25,6 +31,8 @@ pub enum Error {
     DeclarationNotFound(
         // id of the enum declaration
         CanonicalId,
+        // names of the valid declarations
+        Vec<String>,
         // name of the expected declaration
         String,
     ),
@@ -40,6 +48,8 @@ pub enum Error {
     PropertyNotFound(
         // id of the object
         CanonicalId,
+        // names of the valid properties
+        Vec<String>,
         // name of the expected property
         String,
     ),
@@ -56,11 +66,21 @@ pub enum Error {
 
     /* callable-related */
     /// temporary solution until deeper type inference is implemented
-    UntypedParameter,
+    UntypedParameter(String),
 
     DefaultValueRejected(
-        // id of the default value
-        CanonicalId,
+        (
+            // id of the type definition
+            CanonicalId,
+            // the type of the parameter
+            types::Shape,
+        ),
+        (
+            // id of the default value
+            CanonicalId,
+            // the type of the default value
+            types::Shape,
+        ),
     ),
 
     /* function-related */
@@ -72,18 +92,30 @@ pub enum Error {
     UnexpectedArgument(
         // id of the argument
         CanonicalId,
+        // number of arguments expected
+        usize,
     ),
 
     MissingArgument(
         // id of the unfulfilled parameter
         CanonicalId,
+        // the type of the parameter
+        types::Shape,
     ),
 
     ArgumentRejected(
-        // id of the parameter
-        CanonicalId,
-        // id of the argument
-        CanonicalId,
+        (
+            // id of the parameter
+            CanonicalId,
+            // the type of the parameter
+            types::Shape,
+        ),
+        (
+            // id of the argument
+            CanonicalId,
+            // the type of the argument
+            types::Shape,
+        ),
     ),
 
     /* component-related */
@@ -95,6 +127,8 @@ pub enum Error {
     InvalidComponent(
         // tag name
         String,
+        // the type of the value
+        types::Shape,
     ),
 
     ComponentTypo(
@@ -110,37 +144,65 @@ pub enum Error {
     ),
 
     UnexpectedAttribute(
+        // id of the unexpected attribute
+        CanonicalId,
         // name of the attribute
         String,
     ),
 
     MissingAttribute(
-        // id of the unfulfilled parameter
+        // id of the unfulfilled attribute
         CanonicalId,
+        // name of the attribute
+        String,
+        // the type of the attribute
+        types::Shape,
     ),
 
     AttributeRejected(
-        // id of the parameter
-        CanonicalId,
-        // id of the argument
-        CanonicalId,
+        (
+            // id of the parameter
+            CanonicalId,
+            // name of the attribute
+            String,
+            // the type of the parameter
+            types::Shape,
+        ),
+        (
+            // id of the argument
+            CanonicalId,
+            // the type of the argument
+            types::Shape,
+        ),
     ),
 
     /* mismatch */
     BinaryOperationNotSupported(
         // operation being performed
         ast::BinaryOperator,
-        // id of the left-hand side
-        CanonicalId,
-        // id of the right-hand side
-        CanonicalId,
+        (
+            // id of the left-hand side
+            CanonicalId,
+            // the type of the left-hand side
+            Option<types::Shape>,
+        ),
+        (
+            // id of the right-hand side
+            CanonicalId,
+            // the type of the right-hand side
+            Option<types::Shape>,
+        ),
     ),
 
     UnaryOperationNotSupported(
         // operation being performed
         ast::UnaryOperator,
-        // id of the right-hand side
-        CanonicalId,
+        (
+            // id of the right-hand side
+            CanonicalId,
+            // the type of the right-hand side
+            Option<types::Shape>,
+        ),
     ),
 
     UnexpectedKind(

analyze/src/fixture.rs

@@ -3,7 +3,6 @@ use crate::{
     AmbientScope, TypeMap as StrongTypes,
 };
 use kore::str;
-pub use lang::test::fixture::*;
 use lang::{
     ast,
     types::{Enumerated, Kind, Type},
@@ -170,7 +169,10 @@ pub mod function {
         HashMap::from_iter(vec![
             (
                 NodeId(0),
-                (Kind::Value, weak::Type::Infer(Inference::Parameter)),
+                (
+                    Kind::Value,
+                    weak::Type::Infer(Inference::Parameter(str!("first"))),
+                ),
             ),
             (NodeId(1), (Kind::Type, weak::Type::Value(Type::Integer))),
             (

analyze/src/infer/strong/arithmetic.rs

@@ -22,7 +22,11 @@ pub fn infer(state: &State, op: ast::BinaryOperator, lhs: CanonicalId, rhs: Cano
         (Some(Err(_)), _) => Action::Raise(Error::NotInferrable(vec![lhs])),
         (_, Some(Err(_))) => Action::Raise(Error::NotInferrable(vec![rhs])),
 
-        (Some(_), Some(_)) => Action::Raise(Error::BinaryOperationNotSupported(op, lhs, rhs)),
+        (Some(_), Some(_)) => Action::Raise(Error::BinaryOperationNotSupported(
+            op,
+            (lhs, None),
+            (rhs, None),
+        )),
     }
 }
 
@@ -133,8 +137,8 @@ mod tests {
             super::infer(&state, OP, CanonicalId::mock(1), CanonicalId::mock(1)),
             Action::Raise(Error::BinaryOperationNotSupported(
                 OP,
-                CanonicalId::mock(1),
-                CanonicalId::mock(1)
+                (CanonicalId::mock(1), None),
+                (CanonicalId::mock(1), None)
             ))
         );
     }

analyze/src/infer/strong/mock.rs

@@ -7,7 +7,7 @@ pub const FRAGMENTS: &BTreeMap<NodeId, (ScopeId, Fragment)> = &BTreeMap::new();
 
 impl<'a> State<'a> {
     #[allow(clippy::type_complexity)]
-    pub fn mock(context: &'a Context) -> State<'a> {
+    pub fn mock(context: &'a Context) -> Self {
         State {
             context,
             fragments: FRAGMENTS,
@@ -22,7 +22,7 @@ impl<'a> State<'a> {
     pub fn from_types(
         context: &'a Context,
         types: Vec<(NodeId, (Kind, Result<Type, Error>))>,
-    ) -> State<'a> {
+    ) -> Self {
         State {
             types: BTreeMap::from_iter(types),
             ..Self::mock(context)

analyze/src/infer/strong/partial.rs

@@ -93,11 +93,11 @@ pub fn infer_types<'a>(ctx: &Context, prev: State<'a>) -> State<'a> {
             } => import::infer(ctx, source, path),
 
             NodeDescriptor {
-                weak: weak::Type::Infer(Inference::Parameter),
+                weak: weak::Type::Infer(Inference::Parameter(name)),
                 ..
             } => {
                 // TODO: replace this with actual type inference
-                Action::Raise(Error::UntypedParameter)
+                Action::Raise(Error::UntypedParameter(name.to_owned()))
             }
         };