rascal 0.3.1

A parser and compiler for Flash ActionScript 2 files into SWFs
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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

use crate::internal::as2::hir::visitor::{MutVisitor, walk_expr, walk_statement};
use crate::internal::as2::hir::{
    ConstantKind, Declaration, EnumeratorTarget, Expr, ExprKind, ForCondition, Function,
    FunctionArgument, StatementKind,
};
use crate::internal::span::Spanned;
use indexmap::{IndexMap, IndexSet};
use serde::Serialize;

#[derive(Debug, Clone, Serialize, PartialEq, Default)]
pub struct Variable {
    pub used: bool,
    pub used_in_inner_scope: bool,
    pub type_name: Option<Spanned<String>>,
}
#[derive(Debug, Clone, Serialize, PartialEq, Default)]
pub struct Scope {
    pub defined_variables: IndexMap<String, Variable>,
    pub referenced_variables: IndexSet<String>,
    pub could_reference_anything: bool,
}

impl Scope {
    pub fn for_function(
        args: &Vec<FunctionArgument>,
        body: &mut Vec<StatementKind>,
        this_type: Option<Spanned<String>>,
        super_type: Option<Spanned<String>>,
    ) -> Self {
        let mut scope = Scope::default();
        // These must be defined before any arguments, in this order: this arguments super _root _parent _global
        scope.defined_variables.insert(
            "this".to_string(),
            Variable {
                type_name: this_type,
                ..Default::default()
            },
        );
        scope
            .defined_variables
            .insert("arguments".to_string(), Variable::default());
        scope.defined_variables.insert(
            "super".to_string(),
            Variable {
                type_name: super_type,
                ..Default::default()
            },
        );
        scope
            .defined_variables
            .insert("_root".to_string(), Variable::default());
        scope
            .defined_variables
            .insert("_parent".to_string(), Variable::default());
        scope
            .defined_variables
            .insert("_global".to_string(), Variable::default());
        for arg in args {
            scope
                .defined_variables
                .insert(arg.name.clone(), Variable::default());
        }
        let mut finder = VariableFinder(scope);
        for statement in body {
            finder.visit_statement(statement);
        }
        finder.0
    }

    pub fn for_root(body: &mut Vec<StatementKind>) -> Self {
        let mut finder = VariableFinder(Scope::default());
        for statement in body {
            finder.visit_statement(statement);
        }
        finder.0
    }
}

struct VariableFinder(Scope);

impl VariableFinder {
    fn mark_variable_used(&mut self, name: &str, from_inner: bool) {
        if let Some(variable) = self.0.defined_variables.get_mut(name) {
            variable.used = true;
            variable.used_in_inner_scope |= from_inner;
        } else {
            self.0.referenced_variables.insert(name.to_string());
        }
    }

    fn declare_new_variable(&mut self, name: String, type_name: Option<Spanned<String>>) {
        self.0.defined_variables.insert(
            name,
            Variable {
                used: true,
                type_name,
                ..Default::default()
            },
        );
    }
}

impl MutVisitor for VariableFinder {
    fn visit_expr(&mut self, expr: &mut Expr) {
        match &mut expr.value {
            ExprKind::Constant(ConstantKind::Identifier(name)) => {
                self.mark_variable_used(name, false);
            }
            ExprKind::GetVariable(_) => {
                self.0.could_reference_anything = true;
            }
            _ => {}
        }
        walk_expr(self, expr)
    }

    fn visit_function(&mut self, function: &mut Function) {
        // A totally different scope! We don't need to walk it, we can just inspect it.
        self.0.could_reference_anything |= function.scope.could_reference_anything;
        for name in &function.scope.referenced_variables {
            self.mark_variable_used(name, true);
        }
    }

    fn visit_declaration(&mut self, declaration: &mut Declaration) {
        self.declare_new_variable(
            declaration.name.value.clone(),
            declaration.type_name.clone(),
        );
        if let Some(value) = &mut declaration.value {
            self.visit_expr(value);
        }
    }

    fn visit_statement(&mut self, statement: &mut StatementKind) {
        match statement {
            StatementKind::With { .. } => {
                self.0.could_reference_anything = true;
            }
            StatementKind::ForIn {
                condition:
                    ForCondition::Enumerate {
                        target: EnumeratorTarget::Variable { name, declare },
                        ..
                    },
                ..
            } => {
                if *declare {
                    self.declare_new_variable(name.clone(), None);
                } else {
                    self.mark_variable_used(name, false);
                }
            }
            _ => {}
        }
        walk_statement(self, statement);
    }
}