From aea81d3cbfff775f01c30902575c9c1d464f3961 Mon Sep 17 00:00:00 2001
From: Marsel Shaikhin <phoenix.apps@proton.me>
Date: Fri, 8 Nov 2024 09:15:45 +0100
Subject: [PATCH] enh: move `define_emits` and `define_model` to own files,
 support testing binding types

---
 crates/fervid/src/lib.rs                      |   6 +-
 .../fervid_napi/__tests__/defineEmits.spec.ts |  13 +-
 crates/fervid_napi/__tests__/utils.ts         |   5 +-
 crates/fervid_napi/index.d.ts                 |  50 +++
 crates/fervid_napi/index.js                   |   3 +-
 crates/fervid_napi/src/lib.rs                 |  70 ++--
 crates/fervid_napi/src/structs.rs             |  76 +++-
 crates/fervid_transform/src/script/setup.rs   |   6 +
 .../src/script/setup/define_emits.rs          | 192 ++++++++++
 .../src/script/setup/define_model.rs          | 176 +++++++++
 .../src/script/setup/macros.rs                | 357 ++----------------
 11 files changed, 596 insertions(+), 358 deletions(-)
 create mode 100644 crates/fervid_transform/src/script/setup/define_emits.rs
 create mode 100644 crates/fervid_transform/src/script/setup/define_model.rs

diff --git a/crates/fervid/src/lib.rs b/crates/fervid/src/lib.rs
index f1b388c..ef6bf27 100644
--- a/crates/fervid/src/lib.rs
+++ b/crates/fervid/src/lib.rs
@@ -57,7 +57,9 @@ use errors::CompileError;
 use fervid_codegen::CodegenContext;
 pub use fervid_core::*;
 use fervid_parser::SfcParser;
-use fervid_transform::{style::should_transform_style_block, transform_sfc, TransformSfcOptions};
+use fervid_transform::{
+    style::should_transform_style_block, transform_sfc, SetupBinding, TransformSfcOptions,
+};
 use fxhash::FxHasher32;
 use std::{
     borrow::Cow,
@@ -105,6 +107,7 @@ pub struct CompileResult {
     pub styles: Vec<CompileEmittedStyle>,
     pub other_assets: Vec<CompileEmittedAsset>,
     pub source_map: Option<String>,
+    pub setup_bindings: Vec<SetupBinding>,
 }
 
 pub struct CompileEmittedStyle {
@@ -209,6 +212,7 @@ pub fn compile(source: &str, options: CompileOptions) -> Result<CompileResult, C
         styles,
         other_assets,
         source_map,
+        setup_bindings: ctx.bindings_helper.setup_bindings,
     })
 }
 
diff --git a/crates/fervid_napi/__tests__/defineEmits.spec.ts b/crates/fervid_napi/__tests__/defineEmits.spec.ts
index be248c8..9a25a9c 100644
--- a/crates/fervid_napi/__tests__/defineEmits.spec.ts
+++ b/crates/fervid_napi/__tests__/defineEmits.spec.ts
@@ -1,18 +1,19 @@
-// import { BindingTypes } from '@vue/compiler-core'
+import { BindingTypes } from '..'
 import { assertCode, compile } from './utils'
 import { describe, expect, test } from 'vitest'
 
 describe('defineEmits', () => {
   test('basic usage', () => {
-    const { content } = compile(`
+    const { content, bindings } = compile(`
 <script setup>
 const myEmit = defineEmits(['foo', 'bar'])
 </script>
-  `)
+  `, { outputSetupBindings: true })
+
     assertCode(content)
-    // expect(bindings).toStrictEqual({
-    //   myEmit: BindingTypes.SETUP_CONST,
-    // })
+    expect(bindings).toStrictEqual({
+      myEmit: BindingTypes.SetupConst,
+    })
 
     // should remove defineEmits import and call
     expect(content).not.toMatch('defineEmits')
diff --git a/crates/fervid_napi/__tests__/utils.ts b/crates/fervid_napi/__tests__/utils.ts
index dfecbdf..0666b8a 100644
--- a/crates/fervid_napi/__tests__/utils.ts
+++ b/crates/fervid_napi/__tests__/utils.ts
@@ -18,10 +18,11 @@ export function compile(src: string, options?: Partial<FervidCompileOptions>, lo
   if (result.errors.length && logErrors) {
     console.warn(result.errors[0])
   }
-
+  
   return {
     content: result.code,
-    errors: result.errors
+    errors: result.errors,
+    bindings: result.setupBindings,
   }
 }
 
diff --git a/crates/fervid_napi/index.d.ts b/crates/fervid_napi/index.d.ts
index b7247b3..d258282 100644
--- a/crates/fervid_napi/index.d.ts
+++ b/crates/fervid_napi/index.d.ts
@@ -57,6 +57,8 @@ export interface FervidCompileOptions {
   filename: string
   /** Generate a const instead of default export */
   genDefaultAs?: string
+  /** Whether setup bindings need to be serialized */
+  outputSetupBindings?: boolean
 }
 export interface CompileResult {
   code: string
@@ -64,6 +66,7 @@ export interface CompileResult {
   errors: Array<SerializedError>
   customBlocks: Array<CustomBlock>
   sourceMap?: string
+  setupBindings?: Record<string, BindingTypes> | undefined
 }
 export interface Style {
   code: string
@@ -82,6 +85,53 @@ export interface SerializedError {
   hi: number
   message: string
 }
+/**
+ * This is a copied enum from `fervid_core` with `napi` implementation to avoid littering the core crate.
+ *
+ * The type of a binding (or identifier) which is used to show where this binding came from,
+ * e.g. `Data` is for Options API `data()`, `SetupRef` if for `ref`s and `computed`s in Composition API.
+ *
+ * <https://github.com/vuejs/core/blob/020851e57d9a9f727c6ea07e9c1575430af02b73/packages/compiler-core/src/options.ts#L76>
+ */
+export const enum BindingTypes {
+  /** returned from data() */
+  Data = 0,
+  /** declared as a prop */
+  Props = 1,
+  /**
+   * a local alias of a `<script setup>` destructured prop.
+   * the original is stored in __propsAliases of the bindingMetadata object.
+   */
+  PropsAliased = 2,
+  /** a let binding (may or may not be a ref) */
+  SetupLet = 3,
+  /**
+   * a const binding that can never be a ref.
+   * these bindings don't need `unref()` calls when processed in inlined
+   * template expressions.
+   */
+  SetupConst = 4,
+  /** a const binding that does not need `unref()`, but may be mutated. */
+  SetupReactiveConst = 5,
+  /** a const binding that may be a ref */
+  SetupMaybeRef = 6,
+  /** bindings that are guaranteed to be refs */
+  SetupRef = 7,
+  /** declared by other options, e.g. computed, inject */
+  Options = 8,
+  /** a literal constant, e.g. 'foo', 1, true */
+  LiteralConst = 9,
+  /** a `.vue` import or `defineComponent` call */
+  Component = 10,
+  /** an import which is not a `.vue` or `from 'vue'` */
+  Imported = 11,
+  /** a variable from the template */
+  TemplateLocal = 12,
+  /** a variable in the global Javascript context, e.g. `Array` or `undefined` */
+  JsGlobal = 13,
+  /** a non-resolved variable, presumably from the global Vue context */
+  Unresolved = 14,
+}
 export type FervidJsCompiler = Compiler
 /** Fervid: a compiler for Vue.js written in Rust */
 export declare class Compiler {
diff --git a/crates/fervid_napi/index.js b/crates/fervid_napi/index.js
index adaa044..a27d0d1 100644
--- a/crates/fervid_napi/index.js
+++ b/crates/fervid_napi/index.js
@@ -284,6 +284,7 @@ if (!nativeBinding) {
   throw new Error(`Failed to load native binding`)
 }
 
-const { Compiler } = nativeBinding
+const { Compiler, BindingTypes } = nativeBinding
 
 module.exports.Compiler = Compiler
+module.exports.BindingTypes = BindingTypes
diff --git a/crates/fervid_napi/src/lib.rs b/crates/fervid_napi/src/lib.rs
index 1dd103c..06401a4 100644
--- a/crates/fervid_napi/src/lib.rs
+++ b/crates/fervid_napi/src/lib.rs
@@ -10,7 +10,9 @@ use napi::bindgen_prelude::*;
 use napi_derive::napi;
 
 use fervid::{compile, CompileOptions};
-use structs::{CompileResult, FervidCompileOptions, FervidJsCompiler, FervidJsCompilerOptions};
+use structs::{
+    BindingTypes, CompileResult, FervidCompileOptions, FervidJsCompiler, FervidJsCompilerOptions,
+};
 
 mod structs;
 
@@ -25,10 +27,12 @@ impl FervidJsCompiler {
     #[napi]
     pub fn compile_sync(
         &self,
+        env: Env,
         source: String,
         options: FervidCompileOptions,
     ) -> Result<CompileResult> {
-        self.compile_and_convert(&source, &options)
+        let compiled = self.compile_impl(&source, &options)?;
+        Ok(self.convert(env, compiled, &options))
     }
 
     #[napi]
@@ -46,43 +50,63 @@ impl FervidJsCompiler {
         AsyncTask::with_optional_signal(task, signal)
     }
 
-    fn compile_and_convert(
+    fn compile_impl(
         &self,
         source: &str,
         options: &FervidCompileOptions,
-    ) -> Result<CompileResult> {
+    ) -> Result<fervid::CompileResult> {
         // Normalize options to the ones defined in fervid
         let compile_options = CompileOptions {
             filename: Cow::Borrowed(&options.filename),
             id: Cow::Borrowed(&options.id),
             is_prod: self.options.is_production,
             ssr: self.options.ssr,
-            gen_default_as: options.gen_default_as.as_ref().map(|v| Cow::Borrowed(v.as_str())),
-            source_map: self.options.source_map
+            gen_default_as: options
+                .gen_default_as
+                .as_ref()
+                .map(|v| Cow::Borrowed(v.as_str())),
+            source_map: self.options.source_map,
         };
 
-        let native_compile_result =
-            compile(source, compile_options).map_err(|e| Error::from_reason(e.to_string()))?;
+        compile(source, compile_options).map_err(|e| Error::from_reason(e.to_string()))
+    }
+
+    fn convert(
+        &self,
+        env: Env,
+        mut result: fervid::CompileResult,
+        options: &FervidCompileOptions,
+    ) -> CompileResult {
+        // Serialize bindings if requested
+        let setup_bindings = if matches!(options.output_setup_bindings, Some(true)) {
+            env.create_object()
+                .map(|mut obj| {
+                    for binding in result.setup_bindings.drain(..) {
+                        let _ = obj.set(binding.0.as_str(), BindingTypes::from(binding.1));
+                    }
+                    obj
+                })
+                .ok()
+        } else {
+            None
+        };
 
-        Ok(CompileResult {
-            code: native_compile_result.code,
-            source_map: native_compile_result.source_map,
-            custom_blocks: native_compile_result
+        CompileResult {
+            code: result.code,
+            source_map: result.source_map,
+            custom_blocks: result
                 .other_assets
                 .into_iter()
                 .map(|asset| asset.into())
                 .collect(),
-            errors: native_compile_result
-                .errors
-                .into_iter()
-                .map(|e| e.into())
-                .collect(),
-            styles: native_compile_result
+            errors: result.errors.into_iter().map(|e| e.into()).collect(),
+            styles: result
                 .styles
                 .into_iter()
                 .map(|style| style.into())
                 .collect(),
-        })
+            setup_bindings,
+        }
     }
 }
 
@@ -95,13 +119,13 @@ pub struct CompileTask {
 #[napi]
 impl Task for CompileTask {
     type JsValue = CompileResult;
-    type Output = CompileResult;
+    type Output = fervid::CompileResult;
 
     fn compute(&mut self) -> napi::Result<Self::Output> {
-        self.compiler.compile_and_convert(&self.input, &self.options)
+        self.compiler.compile_impl(&self.input, &self.options)
     }
 
-    fn resolve(&mut self, _env: Env, result: Self::Output) -> napi::Result<Self::JsValue> {
-        Ok(result)
+    fn resolve(&mut self, env: Env, result: Self::Output) -> napi::Result<Self::JsValue> {
+        Ok(self.compiler.convert(env, result, &self.options))
     }
 }
diff --git a/crates/fervid_napi/src/structs.rs b/crates/fervid_napi/src/structs.rs
index 3190412..d10274a 100644
--- a/crates/fervid_napi/src/structs.rs
+++ b/crates/fervid_napi/src/structs.rs
@@ -1,3 +1,4 @@
+use napi::JsObject;
 use napi_derive::napi;
 use swc_core::common::Spanned;
 
@@ -60,7 +61,7 @@ pub struct FervidJsCompilerOptionsScript {
     /// Default: true
     pub hoist_static: Option<bool>,
     /// Produce source maps
-    pub source_map: Option<bool>
+    pub source_map: Option<bool>,
 }
 
 #[napi(object)]
@@ -79,6 +80,8 @@ pub struct FervidCompileOptions {
     pub filename: String,
     /// Generate a const instead of default export
     pub gen_default_as: Option<String>,
+    /// Whether setup bindings need to be serialized
+    pub output_setup_bindings: Option<bool>,
 }
 
 #[napi(object)]
@@ -87,7 +90,9 @@ pub struct CompileResult {
     pub styles: Vec<Style>,
     pub errors: Vec<SerializedError>,
     pub custom_blocks: Vec<CustomBlock>,
-    pub source_map: Option<String>
+    pub source_map: Option<String>,
+    #[napi(ts_type = "Record<string, BindingTypes> | undefined")]
+    pub setup_bindings: Option<JsObject>,
 }
 
 #[napi(object)]
@@ -113,6 +118,73 @@ pub struct SerializedError {
     pub message: String,
 }
 
+/// This is a copied enum from `fervid_core` with `napi` implementation to avoid littering the core crate.
+///
+/// The type of a binding (or identifier) which is used to show where this binding came from,
+/// e.g. `Data` is for Options API `data()`, `SetupRef` if for `ref`s and `computed`s in Composition API.
+///
+/// <https://github.com/vuejs/core/blob/020851e57d9a9f727c6ea07e9c1575430af02b73/packages/compiler-core/src/options.ts#L76>
+#[napi]
+pub enum BindingTypes {
+    /// returned from data()
+    Data,
+    /// declared as a prop
+    Props,
+    /// a local alias of a `<script setup>` destructured prop.
+    /// the original is stored in __propsAliases of the bindingMetadata object.
+    PropsAliased,
+    /// a let binding (may or may not be a ref)
+    SetupLet,
+    /// a const binding that can never be a ref.
+    /// these bindings don't need `unref()` calls when processed in inlined
+    /// template expressions.
+    SetupConst,
+    /// a const binding that does not need `unref()`, but may be mutated.
+    SetupReactiveConst,
+    /// a const binding that may be a ref
+    SetupMaybeRef,
+    /// bindings that are guaranteed to be refs
+    SetupRef,
+    /// declared by other options, e.g. computed, inject
+    Options,
+    /// a literal constant, e.g. 'foo', 1, true
+    LiteralConst,
+
+    // Introduced by fervid:
+    /// a `.vue` import or `defineComponent` call
+    Component,
+    /// an import which is not a `.vue` or `from 'vue'`
+    Imported,
+    /// a variable from the template
+    TemplateLocal,
+    /// a variable in the global Javascript context, e.g. `Array` or `undefined`
+    JsGlobal,
+    /// a non-resolved variable, presumably from the global Vue context
+    Unresolved,
+}
+
+impl From<fervid::BindingTypes> for BindingTypes {
+    fn from(value: fervid::BindingTypes) -> Self {
+        match value {
+            fervid::BindingTypes::Data => BindingTypes::Data,
+            fervid::BindingTypes::Props => BindingTypes::Props,
+            fervid::BindingTypes::PropsAliased => BindingTypes::PropsAliased,
+            fervid::BindingTypes::SetupLet => BindingTypes::SetupLet,
+            fervid::BindingTypes::SetupConst => BindingTypes::SetupConst,
+            fervid::BindingTypes::SetupReactiveConst => BindingTypes::SetupReactiveConst,
+            fervid::BindingTypes::SetupMaybeRef => BindingTypes::SetupMaybeRef,
+            fervid::BindingTypes::SetupRef => BindingTypes::SetupRef,
+            fervid::BindingTypes::Options => BindingTypes::Options,
+            fervid::BindingTypes::LiteralConst => BindingTypes::LiteralConst,
+            fervid::BindingTypes::Component => BindingTypes::Component,
+            fervid::BindingTypes::Imported => BindingTypes::Imported,
+            fervid::BindingTypes::TemplateLocal => BindingTypes::TemplateLocal,
+            fervid::BindingTypes::JsGlobal => BindingTypes::JsGlobal,
+            fervid::BindingTypes::Unresolved => BindingTypes::Unresolved,
+        }
+    }
+}
+
 impl From<fervid::CompileEmittedStyle> for Style {
     fn from(value: fervid::CompileEmittedStyle) -> Self {
         Self {
diff --git a/crates/fervid_transform/src/script/setup.rs b/crates/fervid_transform/src/script/setup.rs
index c55e00f..104ecad 100644
--- a/crates/fervid_transform/src/script/setup.rs
+++ b/crates/fervid_transform/src/script/setup.rs
@@ -24,6 +24,8 @@ use crate::{
 };
 
 mod await_detection;
+mod define_emits;
+mod define_model;
 mod define_options;
 mod define_props;
 mod define_slots;
@@ -97,6 +99,8 @@ pub fn transform_and_record_script_setup(
                     &expr_stmt.expr,
                     &mut sfc_object_helper,
                     false,
+                    false,
+                    None,
                     errors,
                 );
 
@@ -236,6 +240,8 @@ fn transform_decl_stmt(
                         init_expr,
                         sfc_object_helper,
                         true,
+                        is_ident,
+                        Some(&mut collected_bindings),
                         errors,
                     );
 
diff --git a/crates/fervid_transform/src/script/setup/define_emits.rs b/crates/fervid_transform/src/script/setup/define_emits.rs
new file mode 100644
index 0000000..e51a7c8
--- /dev/null
+++ b/crates/fervid_transform/src/script/setup/define_emits.rs
@@ -0,0 +1,192 @@
+use fervid_core::{BindingTypes, FervidAtom};
+use fxhash::FxHashSet;
+use itertools::{Either, Itertools};
+use swc_core::{common::{Spanned, DUMMY_SP}, ecma::ast::{ArrayLit, CallExpr, Expr, ExprOrSpread, Ident, Lit, Str, TsFnOrConstructorType, TsFnParam, TsLit, TsType}};
+
+use crate::{atoms::EMIT_HELPER, error::{ScriptError, ScriptErrorKind, TransformError}, script::resolve_type::{resolve_type_elements, resolve_union_type, ResolvedElements, TypeResolveContext}, SetupBinding, SfcExportedObjectHelper, TypeOrDecl};
+
+use super::macros::TransformMacroResult;
+
+pub fn process_define_emits(
+    ctx: &mut TypeResolveContext,
+    call_expr: &CallExpr,
+    is_var_decl: bool,
+    is_ident: bool,
+    var_bindings: Option<&mut Vec<SetupBinding>>,
+    sfc_object_helper: &mut SfcExportedObjectHelper,
+    _errors: &mut Vec<TransformError>,
+) -> TransformMacroResult {
+    // Validation: duplicate call
+    if sfc_object_helper.emits.is_some() {
+        return TransformMacroResult::Error(TransformError::ScriptError(ScriptError {
+            span: call_expr.span,
+            kind: ScriptErrorKind::DuplicateDefineEmits,
+        }));
+    }
+
+    // Validation: both runtime and types
+    if !call_expr.args.is_empty() && call_expr.type_args.is_some() {
+        return TransformMacroResult::Error(TransformError::ScriptError(ScriptError {
+            span: call_expr.span,
+            kind: ScriptErrorKind::DefineEmitsTypeAndNonTypeArguments,
+        }));
+    }
+
+    if let Some(arg0) = &call_expr.args.get(0) {
+        sfc_object_helper.emits = Some(arg0.expr.to_owned())
+    } else if let Some(ref type_args) = call_expr.type_args {
+        let Some(ts_type) = type_args.params.first() else {
+            return TransformMacroResult::Error(TransformError::ScriptError(ScriptError {
+                span: type_args.span,
+                kind: ScriptErrorKind::DefineEmitsMalformed,
+            }));
+        };
+
+        let runtime_emits = match extract_runtime_emits(ctx, &ts_type) {
+            Ok(v) => v,
+            Err(e) => return TransformMacroResult::Error(TransformError::ScriptError(e)),
+        };
+
+        sfc_object_helper.emits = Some(Box::new(Expr::Array(ArrayLit {
+            span: DUMMY_SP,
+            elems: runtime_emits
+                .into_iter()
+                .map(|it| {
+                    Some(ExprOrSpread {
+                        spread: None,
+                        expr: Box::new(Expr::Lit(Lit::Str(Str {
+                            span: DUMMY_SP,
+                            value: it,
+                            raw: None,
+                        }))),
+                    })
+                })
+                .collect_vec(),
+        })))
+    }
+
+    // Return `__emits` when in var mode
+    // Change binding to be `SetupConst`
+    if is_var_decl {
+        sfc_object_helper.is_setup_emit_referenced = true;
+        
+        if let Some(var_bindings) = var_bindings {
+            if is_ident && var_bindings.len() == 1 {
+                let first_binding = &mut var_bindings[0];
+                first_binding.1 = BindingTypes::SetupConst;
+            }
+        }
+
+        TransformMacroResult::ValidMacro(Some(Box::new(Expr::Ident(Ident {
+            span: call_expr.span,
+            ctxt: Default::default(),
+            sym: EMIT_HELPER.to_owned(),
+            optional: false,
+        }))))
+    } else {
+        TransformMacroResult::ValidMacro(None)
+    }
+}
+
+/// Extracts runtime emits from type-only `defineEmits` declaration
+/// Adapted from https://github.com/vuejs/core/blob/0ac0f2e338f6f8f0bea7237db539c68bfafb88ae/packages/compiler-sfc/src/script/defineEmits.ts#L73-L103
+fn extract_runtime_emits(
+    ctx: &mut TypeResolveContext,
+    type_arg: &TsType,
+) -> Result<FxHashSet<FervidAtom>, ScriptError> {
+    let mut emits = FxHashSet::<FervidAtom>::default();
+
+    // Handle cases like `defineEmits<(e: 'foo' | 'bar') => void>()`
+    if let TsType::TsFnOrConstructorType(TsFnOrConstructorType::TsFnType(ref ts_fn_type)) = type_arg
+    {
+        // Expect first param in fn, e.g. `e: 'foo' | 'bar'` in example above
+        let Some(first_fn_param) = ts_fn_type.params.first() else {
+            return Err(ScriptError {
+                span: ts_fn_type.span,
+                kind: ScriptErrorKind::DefineEmitsMalformed,
+            });
+        };
+
+        extract_event_names(ctx, first_fn_param, &mut emits);
+
+        return Ok(emits);
+    }
+
+    let ResolvedElements { props, calls } = resolve_type_elements(ctx, type_arg)?;
+
+    let mut has_property = false;
+    for key in props.into_keys() {
+        emits.insert(key);
+        has_property = true;
+    }
+
+    if !calls.is_empty() {
+        if has_property {
+            return Err(ScriptError {
+                kind: ScriptErrorKind::DefineEmitsMixedCallAndPropertySyntax,
+                span: type_arg.span(),
+            });
+        }
+
+        for call in calls {
+            let (params, span) = match call {
+                Either::Left(l) => (l.params, l.span),
+                Either::Right(r) => (r.params, r.span),
+            };
+
+            let Some(first_param) = params.first() else {
+                return Err(ScriptError {
+                    span,
+                    kind: ScriptErrorKind::ResolveTypeMissingTypeParam,
+                });
+            };
+            extract_event_names(ctx, first_param, &mut emits);
+        }
+    }
+
+    return Ok(emits);
+}
+
+/// Adapted from https://github.com/vuejs/core/blob/0ac0f2e338f6f8f0bea7237db539c68bfafb88ae/packages/compiler-sfc/src/script/defineEmits.ts#L105-L128
+fn extract_event_names(
+    ctx: &mut TypeResolveContext,
+    event_name: &TsFnParam,
+    emits: &mut FxHashSet<FervidAtom>,
+) {
+    let TsFnParam::Ident(ident) = event_name else {
+        return;
+    };
+
+    let Some(ref type_annotation) = ident.type_ann else {
+        return;
+    };
+
+    let scope = ctx.root_scope();
+    let scope = scope.borrow();
+
+    let types = resolve_union_type(ctx, &type_annotation.type_ann, &scope);
+    for ts_type in types {
+        let TypeOrDecl::Type(ts_type) = ts_type else {
+            continue;
+        };
+
+        if let TsType::TsLitType(ts_lit_type) = ts_type.as_ref() {
+            // No UnaryExpression
+            match ts_lit_type.lit {
+                TsLit::Number(ref n) => {
+                    emits.insert(FervidAtom::from(n.value.to_string()));
+                }
+                TsLit::Str(ref s) => {
+                    emits.insert(s.value.to_owned());
+                }
+                TsLit::Bool(ref b) => {
+                    emits.insert(FervidAtom::from(b.value.to_string()));
+                }
+                TsLit::BigInt(ref big_int) => {
+                    emits.insert(FervidAtom::from(big_int.value.to_string()));
+                }
+                TsLit::Tpl(_) => {}
+            }
+        }
+    }
+}
diff --git a/crates/fervid_transform/src/script/setup/define_model.rs b/crates/fervid_transform/src/script/setup/define_model.rs
new file mode 100644
index 0000000..bb901c4
--- /dev/null
+++ b/crates/fervid_transform/src/script/setup/define_model.rs
@@ -0,0 +1,176 @@
+use fervid_core::{fervid_atom, BindingTypes, VueImports};
+use swc_core::ecma::ast::{
+    Bool, CallExpr, Callee, Expr, ExprOrSpread, Ident, IdentName, KeyValueProp, Lit, ObjectLit,
+    Prop, PropName, PropOrSpread, Str,
+};
+
+use crate::{
+    atoms::{MODEL_VALUE, PROPS_HELPER, USE_MODEL_HELPER},
+    BindingsHelper, SetupBinding, SfcDefineModel, SfcExportedObjectHelper,
+};
+
+use super::macros::TransformMacroResult;
+
+pub fn process_define_model(
+    call_expr: &CallExpr,
+    is_var_decl: bool,
+    is_ident: bool,
+    var_bindings: Option<&mut Vec<SetupBinding>>,
+    sfc_object_helper: &mut SfcExportedObjectHelper,
+    bindings_helper: &mut BindingsHelper,
+) -> TransformMacroResult {
+    let define_model = read_define_model(&call_expr.args);
+    let span = call_expr.span;
+
+    // Add to imports
+    bindings_helper.vue_imports |= VueImports::UseModel;
+
+    let use_model_ident = Ident {
+        span,
+        ctxt: Default::default(),
+        sym: USE_MODEL_HELPER.to_owned(),
+        optional: false,
+    };
+
+    let mut use_model_args =
+        Vec::<ExprOrSpread>::with_capacity(if define_model.local { 3 } else { 2 });
+
+    // __props
+    sfc_object_helper.is_setup_props_referenced = true;
+    use_model_args.push(ExprOrSpread {
+        spread: None,
+        expr: Box::new(Expr::Ident(Ident {
+            span,
+            ctxt: Default::default(),
+            sym: PROPS_HELPER.to_owned(),
+            optional: false,
+        })),
+    });
+
+    // "model-name"
+    let model_name = define_model.name.to_owned();
+    use_model_args.push(ExprOrSpread {
+        spread: None,
+        expr: Box::new(Expr::Lit(Lit::Str(Str {
+            span,
+            value: model_name.to_owned(),
+            raw: None,
+        }))),
+    });
+
+    // `{ local: true }` if needed
+    if define_model.local {
+        use_model_args.push(ExprOrSpread {
+            spread: None,
+            expr: Box::new(Expr::Object(ObjectLit {
+                span,
+                props: vec![PropOrSpread::Prop(Box::new(Prop::KeyValue(KeyValueProp {
+                    key: PropName::Ident(IdentName {
+                        span,
+                        sym: fervid_atom!("local"),
+                    }),
+                    value: Box::new(Expr::Lit(Lit::Bool(Bool { span, value: true }))),
+                })))],
+            })),
+        })
+    }
+
+    sfc_object_helper.models.push(define_model);
+
+    // Binding type of the prop
+    bindings_helper
+        .setup_bindings
+        .push(SetupBinding(model_name, BindingTypes::Props));
+
+    // Binding type of the model itself
+    if let (true, true, Some(var_bindings)) = (is_var_decl, is_ident, var_bindings) {
+        if var_bindings.len() == 1 {
+            let binding = &mut var_bindings[0];
+            binding.1 = BindingTypes::SetupRef;
+        }
+    }
+
+    // _useModel(__props, "model-name", %model options%)
+    TransformMacroResult::ValidMacro(Some(Box::new(Expr::Call(CallExpr {
+        span,
+        ctxt: Default::default(),
+        callee: Callee::Expr(Box::new(Expr::Ident(use_model_ident))),
+        args: use_model_args,
+        type_args: None,
+    }))))
+}
+
+/// Processes `defineModel`
+fn read_define_model(macro_args: &[ExprOrSpread]) -> SfcDefineModel {
+    // 1st arg - model name (string) or model options (object)
+    let first_arg = macro_args.get(0);
+
+    // 2nd arg - model options (object)
+    let second_arg = macro_args.get(1);
+
+    // Get name. It may be a first argument, or may be omitted altogether (defaults to `modelValue`)
+    let (name, is_first_arg_name) = match first_arg {
+        Some(ExprOrSpread { spread: None, expr }) => match **expr {
+            Expr::Lit(Lit::Str(ref name)) => (name.value.to_owned(), true),
+            _ => (MODEL_VALUE.to_owned(), false),
+        },
+
+        _ => (MODEL_VALUE.to_owned(), false),
+    };
+
+    let options: Option<&ExprOrSpread> = if is_first_arg_name {
+        second_arg
+    } else {
+        first_arg
+    };
+
+    // Check if options is an object, we'll need `local` option from it
+    let local = is_local(options);
+
+    SfcDefineModel {
+        name,
+        local,
+        options: options.map(|o| Box::new(o.to_owned())),
+    }
+}
+
+/// Dig into options and find `local` field in the object with a boolean value.
+/// If property is not found or `options` is not a proper object, `false` is returned.
+fn is_local(options: Option<&ExprOrSpread>) -> bool {
+    let Some(ExprOrSpread { spread: None, expr }) = options else {
+        return false;
+    };
+
+    let Expr::Object(ref obj) = **expr else {
+        return false;
+    };
+
+    let local_prop_value = obj.props.iter().find_map(|prop| match prop {
+        PropOrSpread::Prop(prop) => {
+            let Prop::KeyValue(ref key_value) = **prop else {
+                return None;
+            };
+
+            match key_value.key {
+                PropName::Ident(ref ident) if ident.sym == fervid_atom!("local") => {
+                    Some(&key_value.value)
+                }
+
+                PropName::Str(ref s) if s.value == fervid_atom!("local") => Some(&key_value.value),
+
+                _ => None,
+            }
+        }
+        _ => None,
+    });
+
+    let Some(local_prop_value) = local_prop_value else {
+        return false;
+    };
+
+    let Expr::Lit(Lit::Bool(ref local_bool)) = **local_prop_value else {
+        return false;
+    };
+
+    local_bool.value
+}
diff --git a/crates/fervid_transform/src/script/setup/macros.rs b/crates/fervid_transform/src/script/setup/macros.rs
index 75c6661..a2d74c9 100644
--- a/crates/fervid_transform/src/script/setup/macros.rs
+++ b/crates/fervid_transform/src/script/setup/macros.rs
@@ -1,30 +1,30 @@
-use fervid_core::{fervid_atom, FervidAtom, IntoIdent, VueImports};
-use fxhash::FxHashSet;
-use itertools::{Either, Itertools};
+use fervid_core::{FervidAtom, IntoIdent, VueImports};
 use swc_core::{
-    common::{Spanned, DUMMY_SP},
+    common::DUMMY_SP,
     ecma::ast::{
-        ArrayLit, Bool, CallExpr, Callee, Expr, ExprOrSpread, Ident, IdentName, KeyValueProp, Lit,
-        ObjectLit, Prop, PropName, PropOrSpread, Str, TsFnOrConstructorType, TsFnParam, TsLit,
-        TsType,
+        ArrayLit, CallExpr, Callee, Expr, ExprOrSpread, Ident, KeyValueProp, Lit, ObjectLit, Prop,
+        PropName, PropOrSpread, Str,
     },
 };
 
 use crate::{
     atoms::{
         DEFINE_EMITS, DEFINE_EXPOSE, DEFINE_MODEL, DEFINE_OPTIONS, DEFINE_PROPS, DEFINE_SLOTS,
-        EMIT_HELPER, EXPOSE_HELPER, MERGE_MODELS_HELPER, MODEL_VALUE, PROPS_HELPER,
-        USE_MODEL_HELPER, WITH_DEFAULTS,
+        EXPOSE_HELPER, MERGE_MODELS_HELPER, WITH_DEFAULTS,
     },
-    error::{ScriptError, ScriptErrorKind, TransformError},
+    error::TransformError,
     script::{
-        resolve_type::{
-            resolve_type_elements, resolve_union_type, ResolvedElements, TypeResolveContext,
+        resolve_type::TypeResolveContext,
+        setup::{
+            define_emits::process_define_emits,
+            define_model::process_define_model,
+            define_options::process_define_options,
+            define_props::{process_define_props, process_with_defaults},
+            define_slots::process_define_slots,
         },
-        setup::{define_options::process_define_options, define_props::{process_define_props, process_with_defaults}, define_slots::process_define_slots},
     },
-    structs::{SfcDefineModel, SfcExportedObjectHelper},
-    BindingsHelper, TypeOrDecl,
+    structs::SfcExportedObjectHelper,
+    BindingsHelper, SetupBinding,
 };
 
 pub enum TransformMacroResult {
@@ -43,6 +43,8 @@ pub fn transform_script_setup_macro_expr(
     expr: &Expr,
     sfc_object_helper: &mut SfcExportedObjectHelper,
     is_var_decl: bool,
+    is_ident: bool,
+    var_bindings: Option<&mut Vec<SetupBinding>>,
     errors: &mut Vec<TransformError>,
 ) -> TransformMacroResult {
     // `defineExpose` and `defineModel` actually generate something
@@ -93,70 +95,15 @@ pub fn transform_script_setup_macro_expr(
     } else if WITH_DEFAULTS.eq(sym) {
         process_with_defaults(ctx, call_expr, is_var_decl, sfc_object_helper)
     } else if DEFINE_EMITS.eq(sym) {
-        // Validation: duplicate call
-        if sfc_object_helper.emits.is_some() {
-            return TransformMacroResult::Error(TransformError::ScriptError(ScriptError {
-                span: call_expr.span,
-                kind: ScriptErrorKind::DuplicateDefineEmits,
-            }));
-        }
-
-        // Validation: both runtime and types
-        if !call_expr.args.is_empty() && call_expr.type_args.is_some() {
-            return TransformMacroResult::Error(TransformError::ScriptError(ScriptError {
-                span: call_expr.span,
-                kind: ScriptErrorKind::DefineEmitsTypeAndNonTypeArguments,
-            }));
-        }
-
-        if let Some(arg0) = &call_expr.args.get(0) {
-            sfc_object_helper.emits = Some(arg0.expr.to_owned())
-        } else if let Some(ref type_args) = call_expr.type_args {
-            let Some(ts_type) = type_args.params.first() else {
-                return TransformMacroResult::Error(TransformError::ScriptError(ScriptError {
-                    span: type_args.span,
-                    kind: ScriptErrorKind::DefineEmitsMalformed,
-                }));
-            };
-
-            let runtime_emits = match extract_runtime_emits(ctx, &ts_type) {
-                Ok(v) => v,
-                Err(e) => return TransformMacroResult::Error(TransformError::ScriptError(e)),
-            };
-
-            sfc_object_helper.emits = Some(Box::new(Expr::Array(ArrayLit {
-                span: DUMMY_SP,
-                elems: runtime_emits
-                    .into_iter()
-                    .map(|it| {
-                        Some(ExprOrSpread {
-                            spread: None,
-                            expr: Box::new(Expr::Lit(Lit::Str(Str {
-                                span: DUMMY_SP,
-                                value: it,
-                                raw: None,
-                            }))),
-                        })
-                    })
-                    .collect_vec(),
-            })))
-        }
-
-        // TODO Process type declaration
-
-        // Return `__emits` when in var mode
-        if is_var_decl {
-            sfc_object_helper.is_setup_emit_referenced = true;
-
-            valid_macro!(Some(Box::new(Expr::Ident(Ident {
-                span,
-                ctxt: Default::default(),
-                sym: EMIT_HELPER.to_owned(),
-                optional: false,
-            }))))
-        } else {
-            valid_macro!(None)
-        }
+        process_define_emits(
+            ctx,
+            call_expr,
+            is_var_decl,
+            is_ident,
+            var_bindings,
+            sfc_object_helper,
+            errors,
+        )
     } else if DEFINE_EXPOSE.eq(sym) {
         sfc_object_helper.is_setup_expose_referenced = true;
 
@@ -177,72 +124,14 @@ pub fn transform_script_setup_macro_expr(
             type_args: None,
         }))))
     } else if DEFINE_MODEL.eq(sym) {
-        let define_model = read_define_model(&call_expr.args);
-
-        // Add to imports
-        bindings_helper.vue_imports |= VueImports::UseModel;
-
-        // TODO Add model identifier as a binding (when `is_var_decl == true`)
-
-        let use_model_ident = Ident {
-            span,
-            ctxt: Default::default(),
-            sym: USE_MODEL_HELPER.to_owned(),
-            optional: false,
-        };
-
-        let mut use_model_args =
-            Vec::<ExprOrSpread>::with_capacity(if define_model.local { 3 } else { 2 });
-
-        // __props
-        sfc_object_helper.is_setup_props_referenced = true;
-        use_model_args.push(ExprOrSpread {
-            spread: None,
-            expr: Box::new(Expr::Ident(Ident {
-                span,
-                ctxt: Default::default(),
-                sym: PROPS_HELPER.to_owned(),
-                optional: false,
-            })),
-        });
-
-        // "model-name"
-        use_model_args.push(ExprOrSpread {
-            spread: None,
-            expr: Box::new(Expr::Lit(Lit::Str(Str {
-                span,
-                value: define_model.name.to_owned(),
-                raw: None,
-            }))),
-        });
-
-        // `{ local: true }` if needed
-        if define_model.local {
-            use_model_args.push(ExprOrSpread {
-                spread: None,
-                expr: Box::new(Expr::Object(ObjectLit {
-                    span,
-                    props: vec![PropOrSpread::Prop(Box::new(Prop::KeyValue(KeyValueProp {
-                        key: PropName::Ident(IdentName {
-                            span,
-                            sym: fervid_atom!("local"),
-                        }),
-                        value: Box::new(Expr::Lit(Lit::Bool(Bool { span, value: true }))),
-                    })))],
-                })),
-            })
-        }
-
-        sfc_object_helper.models.push(define_model);
-
-        // _useModel(__props, "model-name", %model options%)
-        valid_macro!(Some(Box::new(Expr::Call(CallExpr {
-            span,
-            ctxt: Default::default(),
-            callee: Callee::Expr(Box::new(Expr::Ident(use_model_ident))),
-            args: use_model_args,
-            type_args: None,
-        }))))
+        process_define_model(
+            call_expr,
+            is_var_decl,
+            is_ident,
+            var_bindings,
+            sfc_object_helper,
+            bindings_helper,
+        )
     } else if DEFINE_SLOTS.eq(sym) {
         process_define_slots(call_expr, is_var_decl, sfc_object_helper, bindings_helper)
     } else if DEFINE_OPTIONS.eq(sym) {
@@ -397,181 +286,3 @@ pub fn postprocess_macros(
         _ => {}
     }
 }
-
-/// Processes `defineModel`
-fn read_define_model(macro_args: &[ExprOrSpread]) -> SfcDefineModel {
-    // 1st arg - model name (string) or model options (object)
-    let first_arg = macro_args.get(0);
-
-    // 2nd arg - model options (object)
-    let second_arg = macro_args.get(1);
-
-    // Get name. It may be a first argument, or may be omitted altogether (defaults to `modelValue`)
-    let (name, is_first_arg_name) = match first_arg {
-        Some(ExprOrSpread { spread: None, expr }) => match **expr {
-            Expr::Lit(Lit::Str(ref name)) => (name.value.to_owned(), true),
-            _ => (MODEL_VALUE.to_owned(), false),
-        },
-
-        _ => (MODEL_VALUE.to_owned(), false),
-    };
-
-    let options: Option<&ExprOrSpread> = if is_first_arg_name {
-        second_arg
-    } else {
-        first_arg
-    };
-
-    // Check if options is an object, we'll need `local` option from it
-    let local = is_local(options);
-
-    SfcDefineModel {
-        name,
-        local,
-        options: options.map(|o| Box::new(o.to_owned())),
-    }
-}
-
-/// Dig into options and find `local` field in the object with a boolean value.
-/// If property is not found or `options` is not a proper object, `false` is returned.
-fn is_local(options: Option<&ExprOrSpread>) -> bool {
-    let Some(ExprOrSpread { spread: None, expr }) = options else {
-        return false;
-    };
-
-    let Expr::Object(ref obj) = **expr else {
-        return false;
-    };
-
-    let local_prop_value = obj.props.iter().find_map(|prop| match prop {
-        PropOrSpread::Prop(prop) => {
-            let Prop::KeyValue(ref key_value) = **prop else {
-                return None;
-            };
-
-            match key_value.key {
-                PropName::Ident(ref ident) if ident.sym == fervid_atom!("local") => {
-                    Some(&key_value.value)
-                }
-
-                PropName::Str(ref s) if s.value == fervid_atom!("local") => Some(&key_value.value),
-
-                _ => None,
-            }
-        }
-        _ => None,
-    });
-
-    let Some(local_prop_value) = local_prop_value else {
-        return false;
-    };
-
-    let Expr::Lit(Lit::Bool(ref local_bool)) = **local_prop_value else {
-        return false;
-    };
-
-    local_bool.value
-}
-
-/// Extracts runtime emits from type-only `defineEmits` declaration
-/// Adapted from https://github.com/vuejs/core/blob/0ac0f2e338f6f8f0bea7237db539c68bfafb88ae/packages/compiler-sfc/src/script/defineEmits.ts#L73-L103
-fn extract_runtime_emits(
-    ctx: &mut TypeResolveContext,
-    type_arg: &TsType,
-) -> Result<FxHashSet<FervidAtom>, ScriptError> {
-    let mut emits = FxHashSet::<FervidAtom>::default();
-
-    // Handle cases like `defineEmits<(e: 'foo' | 'bar') => void>()`
-    if let TsType::TsFnOrConstructorType(TsFnOrConstructorType::TsFnType(ref ts_fn_type)) = type_arg
-    {
-        // Expect first param in fn, e.g. `e: 'foo' | 'bar'` in example above
-        let Some(first_fn_param) = ts_fn_type.params.first() else {
-            return Err(ScriptError {
-                span: ts_fn_type.span,
-                kind: ScriptErrorKind::DefineEmitsMalformed,
-            });
-        };
-
-        extract_event_names(ctx, first_fn_param, &mut emits);
-
-        return Ok(emits);
-    }
-
-    let ResolvedElements { props, calls } = resolve_type_elements(ctx, type_arg)?;
-
-    let mut has_property = false;
-    for key in props.into_keys() {
-        emits.insert(key);
-        has_property = true;
-    }
-
-    if !calls.is_empty() {
-        if has_property {
-            return Err(ScriptError {
-                kind: ScriptErrorKind::DefineEmitsMixedCallAndPropertySyntax,
-                span: type_arg.span(),
-            });
-        }
-
-        for call in calls {
-            let (params, span) = match call {
-                Either::Left(l) => (l.params, l.span),
-                Either::Right(r) => (r.params, r.span),
-            };
-
-            let Some(first_param) = params.first() else {
-                return Err(ScriptError {
-                    span,
-                    kind: ScriptErrorKind::ResolveTypeMissingTypeParam,
-                });
-            };
-            extract_event_names(ctx, first_param, &mut emits);
-        }
-    }
-
-    return Ok(emits);
-}
-
-/// Adapted from https://github.com/vuejs/core/blob/0ac0f2e338f6f8f0bea7237db539c68bfafb88ae/packages/compiler-sfc/src/script/defineEmits.ts#L105-L128
-fn extract_event_names(
-    ctx: &mut TypeResolveContext,
-    event_name: &TsFnParam,
-    emits: &mut FxHashSet<FervidAtom>,
-) {
-    let TsFnParam::Ident(ident) = event_name else {
-        return;
-    };
-
-    let Some(ref type_annotation) = ident.type_ann else {
-        return;
-    };
-
-    let scope = ctx.root_scope();
-    let scope = scope.borrow();
-
-    let types = resolve_union_type(ctx, &type_annotation.type_ann, &scope);
-    for ts_type in types {
-        let TypeOrDecl::Type(ts_type) = ts_type else {
-            continue;
-        };
-
-        if let TsType::TsLitType(ts_lit_type) = ts_type.as_ref() {
-            // No UnaryExpression
-            match ts_lit_type.lit {
-                TsLit::Number(ref n) => {
-                    emits.insert(FervidAtom::from(n.value.to_string()));
-                }
-                TsLit::Str(ref s) => {
-                    emits.insert(s.value.to_owned());
-                }
-                TsLit::Bool(ref b) => {
-                    emits.insert(FervidAtom::from(b.value.to_string()));
-                }
-                TsLit::BigInt(ref big_int) => {
-                    emits.insert(FervidAtom::from(big_int.value.to_string()));
-                }
-                TsLit::Tpl(_) => {}
-            }
-        }
-    }
-}