mica 0.7.1

A simple, user-friendly, embeddable scripting language
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

//! Code generation for various types of function calls.

use std::rc::Rc;

use super::{CodeGenerator, Expression, ExpressionResult};
use crate::{
    ll::{
        ast::{Ast, NodeId, NodeKind},
        bytecode::{MethodSignature, Opcode, Opr24},
        error::{LanguageError, LanguageErrorKind},
    },
    MethodParameterCount,
};

impl<'e> CodeGenerator<'e> {
    /// Generates code for a function call.
    pub(super) fn generate_call(
        &mut self,
        ast: &Ast,
        node: NodeId,
    ) -> Result<ExpressionResult, LanguageError> {
        let (function, _) = ast.node_pair(node);
        match ast.kind(function) {
            // Method calls need special treatment.
            NodeKind::Dot => {
                let (receiver, name) = ast.node_pair(function);
                if ast.kind(name) != NodeKind::Identifier {
                    return Err(ast.error(name, LanguageErrorKind::InvalidMethodName));
                }
                let name = ast.string(name).unwrap();

                // Generate the receiver and arguments.
                self.generate_node(ast, receiver, Expression::Used)?;
                let arguments = ast.children(node).unwrap();
                for &argument in arguments {
                    self.generate_node(ast, argument, Expression::Used)?;
                }

                // Construct the call.
                let parameter_count =
                    MethodParameterCount::from_count_without_self(arguments.len())
                        .map_err(|_| ast.error(node, LanguageErrorKind::TooManyArguments))?;
                let signature = MethodSignature::new(Rc::clone(name), parameter_count);
                let method_index = self
                    .env
                    .get_or_create_method_index(&signature)
                    .map_err(|kind| ast.error(node, kind))?;
                self.chunk.emit((
                    Opcode::CallMethod,
                    Opr24::pack((method_index.to_u16(), parameter_count.to_count_with_self())),
                ));
            }
            _ => {
                self.generate_node(ast, function, Expression::Used)?;
                let arguments = ast.children(node).unwrap();
                for &argument in arguments {
                    self.generate_node(ast, argument, Expression::Used)?;
                }
                self.chunk.emit((
                    Opcode::Call,
                    Opr24::try_from(arguments.len())
                        .map_err(|_| ast.error(node, LanguageErrorKind::TooManyArguments))?,
                ));
            }
        }
        Ok(ExpressionResult::Present)
    }

    /// Generates code for a bare dot call (without parentheses).
    pub(super) fn generate_dot(
        &mut self,
        ast: &Ast,
        node: NodeId,
    ) -> Result<ExpressionResult, LanguageError> {
        let (left, method) = ast.node_pair(node);
        self.generate_node(ast, left, Expression::Used)?;

        if ast.kind(method) != NodeKind::Identifier {
            return Err(ast.error(method, LanguageErrorKind::InvalidMethodName));
        }
        let signature = MethodSignature::new(
            Rc::clone(ast.string(method).unwrap()),
            MethodParameterCount::from_count_with_self(1),
        );
        let method_index = self
            .env
            .get_or_create_method_index(&signature)
            .map_err(|kind| ast.error(node, kind))?;
        self.chunk.emit((Opcode::CallMethod, Opr24::pack((method_index.to_u16(), 1))));

        Ok(ExpressionResult::Present)
    }
}