diff options
Diffstat (limited to 'tiger-compiler/src/object/desugar-visitor.cc')
| -rw-r--r-- | tiger-compiler/src/object/desugar-visitor.cc | 1127 |
1 files changed, 1127 insertions, 0 deletions
diff --git a/tiger-compiler/src/object/desugar-visitor.cc b/tiger-compiler/src/object/desugar-visitor.cc new file mode 100644 index 0000000..db61a80 --- /dev/null +++ b/tiger-compiler/src/object/desugar-visitor.cc @@ -0,0 +1,1127 @@ +/** + ** \file object/desugar-visitor.cc + ** \brief Implementation of object::DesugarVisitor. + */ + +#include <sstream> + +#include <algorithm> +#include <ast/all.hh> +#include <misc/contract.hh> +#include <misc/set.hh> +#include <misc/symbol.hh> +#include <object/desugar-visitor.hh> +#include <parse/libparse.hh> +#include <parse/tweast.hh> +#include <type/class.hh> +#include <type/function.hh> +#include <type/record.hh> + +namespace object +{ + DesugarVisitor::DesugarVisitor(const class_names_type& names) + : class_names_(names) + {} + + /*---------------------------. + | Handling names and types. | + `---------------------------*/ + + namespace + { + // Desugar prefixes. + + // Prefix of every class id (label). + const char* class_id_prefix = "_id_"; + // Prefix of every record holding the contents of a desugared class. + const char* class_contents_prefix = "_contents_"; + // Prefix of every variant storing the possible dynamic type for + // a given static type. + const char* class_variant_prefix = "_variant_"; + // Prefix of the fields in the variant. + const char* variant_field_prefix = "field_"; + // Prefix of constructors. + const char* class_ctor_prefix = "_new_"; + // Prefix of methods. + const char* method_prefix = "_method_"; + + // Useful routines. + + // Try to get the class type of \a t. If \a t is not a class + // type, return a null pointer. + const type::Class* class_type_query(const ast::Typable& t) + { + // FIXME DONE: Some code was deleted here. + return dynamic_cast<const type::Class*>(&t.type_get()->actual()); + } + + // Like class_type_query, but ensure the type is actually a class. + const type::Class* class_type_get(const ast::Typable& t) + { + const type::Class* class_type = class_type_query(t); + postcondition(class_type); + return class_type; + } + + } // namespace + + /*------------------. + | Code generation. | + `------------------*/ + + std::string DesugarVisitor::type_symbol(const type::Type* type) + { + // FIXME DONE: Some code was deleted here (Check int, then string, then class name). + if (dynamic_cast<const type::Int*>(type)) + { + return "int"; + } + else if (dynamic_cast<const type::String*>(type)) + { + return "string"; + } + else if (const auto named = dynamic_cast<const type::Named*>(type)) + { + return named->name_get().get(); + } + else + { + throw std::invalid_argument("type was neither a builtin or named"); + } + } + + std::string DesugarVisitor::upcast_fun_name(const type::Class* from, + const type::Class* to) + { + std::stringstream s; + s << "_upcast_" << class_names_(from) << "_to_" << class_names_(to); + return s.str(); + } + + std::string DesugarVisitor::downcast_fun_name(const type::Class* from, + const type::Class* to) + { + std::stringstream s; + s << "_downcast_" << class_names_(from) << "_to_" << class_names_(to); + return s.str(); + } + + std::string DesugarVisitor::dispatch_fun_name(const type::Class* owner, + const type::Method* method) + { + std::stringstream s; + // If an extension is found, add it to the dispatch suffix. + if (dispatch_map_.find(method) != dispatch_map_.end()) + s << "_dispatch_" << dispatch_map_[method] << "_" << class_names_(owner) + << "_" << method->name_get(); + else + s << "_dispatch_" << class_names_(owner) << "_" << method->name_get(); + + return s.str(); + } + + void DesugarVisitor::adapt_type(ast::Exp*& source_exp, + const type::Class* source_type, + const type::Class* target_type) + { + // If the source type is different from the target type, (up)cast + // the source expression to the latter. + if (source_type && target_type && source_type != target_type) + source_exp = parse::parse(parse::Tweast() + << upcast_fun_name(source_type, target_type) + << " (" << source_exp << ")"); + } + + ast::Exp* DesugarVisitor::variant_exp(const type::Class* static_type, + const std::string& exact_type, + const field_inits_type& inits) + { + parse::Tweast input; + misc::symbol static_type_name = class_names_(static_type); + input << " " << class_variant_prefix << static_type_name + << " {" + " exact_type = " + << exact_type; + /* For each field of the variant, store the corresponding + initialization value if one was given, otherwise set the field + to `nil'. */ + // Fields of the static type. + for (const type::Class* c = static_type; c; c = c->super_get()) + // Don't generate slots for classes with no data. + if (c->has_data()) + { + input << ",\n" << variant_field_prefix << class_names_(c) << " = "; + // These fields must have a value (we don't need to put an + // assertion here, misc::map::operator() already handles this. + std::string init = inits.operator()(c); + input << init; + } + // Potential fields of the dynamic type (from subclasses of the + // static type). + for (const type::Class* subclass : static_type->subclasses_get()) + // Don't generate slots for classes with no data. + if (subclass->has_data()) + { + input << ",\n" + << variant_field_prefix << class_names_(subclass) << " = "; + // These fields might be nil. + const auto i = inits.find(subclass); + if (i != inits.end()) + input << i->second; + else + input << "nil"; + } + input << " }\n"; + return parse::parse(input); + } + + // Syntactic sugar. + ast::Exp* DesugarVisitor::variant_exp(const type::Class* static_type, + const type::Class* dynamic_type, + const field_inits_type& inits) + { + std::string exact_type = class_id_prefix + class_names_(dynamic_type).get(); + return variant_exp(static_type, exact_type, inits); + } + + void DesugarVisitor::fill_variant_fields(const type::Class* class_type, + parse::Tweast* input) + { + // Don't generate slots for classes with no data. + if (class_type->has_data()) + { + misc::symbol class_name = class_names_(class_type); + *input << ",\n" + << " " << variant_field_prefix << class_name << " : " + << " " << class_contents_prefix << class_name; + } + } + + // Desugar a class type as a variant (record) type. + parse::Tweast* DesugarVisitor::variant_ty(const type::Class* class_type) + { + auto input = new parse::Tweast; + *input << " {" + << " exact_type : int"; + // Actual data slots. + /* First, populate the variant with mandatory fields (always non + nil) starting with the type of the visited class, then super + classes. */ + for (const type::Class* c = class_type; c; c = c->super_get()) + fill_variant_fields(c, input); + /* Then add all subclasses types. These might be nil, according to + the exact type of the object. */ + for (const type::Class* subclass : class_type->subclasses_get()) + fill_variant_fields(subclass, input); + *input << " }\n"; + return input; + } + + void DesugarVisitor::fill_init_list(const type::Class* class_type, + field_inits_type& inits) + { + // Populate the initialization list with classes + // owning actual data only. + if (class_type->has_data()) + { + std::string field_name = class_names_(class_type); + misc::put(inits, class_type, + std::string("source.") + variant_field_prefix + field_name); + } + } + + parse::Tweast* DesugarVisitor::cast_function(const std::string& name, + const type::Class* source, + const type::Class* target, + const type::Class* exact_type) + { + auto input = new parse::Tweast; + *input << " function " << name << " (source : " << class_variant_prefix + << class_names_(source) + << ") :" + " " + << class_variant_prefix << class_names_(target) << " = "; + + // Copy all fields from the source. + field_inits_type inits; + // First, fields from the class and its super classes... + for (const type::Class* c = source; c; c = c->super_get()) + fill_init_list(c, inits); + // ...then, fields from the subclasses. + for (const type::Class* c : source->subclasses_get()) + fill_init_list(c, inits); + *input << variant_exp(target, exact_type, inits) << "\n"; + return input; + } + + parse::Tweast* DesugarVisitor::upcast_function(const type::Class* source, + const type::Class* target) + { + return cast_function(upcast_fun_name(source, target), source, target, + source); + } + + parse::Tweast* DesugarVisitor::downcast_function(const type::Class* source, + const type::Class* target) + { + return cast_function(downcast_fun_name(source, target), source, target, + target); + } + + ast::Exp* DesugarVisitor::dispatch_switch(const type::Class* class_type, + const type::Method* method, + const ast::TypeChunk* typechunk, + const type::Method* dispatch_method) + { + parse::Tweast input; + misc::symbol method_name = method->name_get(); + // If a recursive call is needed, dispatch_method will not be + // nullptr. It means that during the dispatch function + // declaration, formals of the mother method have been used + // (because of the use of dispatch_map_, we cannot use child's + // formals. + const ast::MethodDec* def; + // FIXME DONE: Some code was deleted here (Initialize def). + def = dispatch_method ? dispatch_method->def_get() : method->def_get(); + const ast::VarChunk& formals = def->formals_get(); + + // Create a case for each method redefinition. + classes_type overridings; + for (const type::Class* c : class_type->subclasses_get()) + if (std::ranges::any_of(*typechunk, [c](const ast::TypeDec* tmp) { + return class_type_query(*tmp) == c; + })) + overridings.emplace_back(c); + + if (overridings.empty()) + // No dispatch is needed; simply call the method. + input << method_call(class_names_(class_type), method_name, "self", + formals); + else + { + // Emit code for self. + bool first = true; + // Emit code for other types. + for (auto c : overridings) + { + if (!first) + input << " else "; + input << " if self.exact_type = " << class_id_prefix + << class_names_(c) << " then "; + // We search for the nearest implementation of our method. + const type::Class* nearest_c = c; + while (nearest_c && !(nearest_c->owned_meth_find(method_name))) + nearest_c = nearest_c->super_get(); + input << method_call( + class_names_(nearest_c), method_name, + ((*class_type != *nearest_c) + ? downcast_fun_name(class_type, nearest_c) + " (self)" + : "self"), + formals); + first = false; + } + input << " else "; + // If this is a sub dispatch function, call the last dispatch + // method built so we don't need to write every single test + // for exact_type. + if (dispatch_method) + { + input << "_dispatch_"; + if ((dispatch_map_[method] - 1) != 1) + input << (dispatch_map_[method] - 1) << "_"; + input << class_names_(class_type) << "_" << method->name_get() + << " (self"; + // Get the other arguments. + for (const ast::VarDec* arg : formals) + input << ", " << arg->name_get(); + input << ")"; + } + else + input << method_call(class_names_(class_type), method_name, "self", + formals); + } + input << '\n'; + return parse::parse(input); + } + + parse::Tweast* DesugarVisitor::method_call(misc::symbol class_name, + misc::symbol method_name, + const std::string& target, + const ast::VarChunk& formals) + { + auto input = new parse::Tweast; + *input << method_prefix << class_name << "_" << method_name << " ("; + + // Pass the target. + // FIXME DONE: Some code was deleted here. + *input << target; + + // Pass other arguments. + // FIXME DONE: Some code was deleted here. + for (const auto var : formals) + { + // FIXME: Is potentially wrong + *input << ", " << *recurse(*var); + } + + *input << ")"; + return input; + } + + /*------------------------. + | Visiting declarations. | + `------------------------*/ + + void DesugarVisitor::operator()(const ast::ChunkList& e) + { + const ast::Location& location = e.location_get(); + // This is an inlined and specialized version of + // astclone::Cloner::recurse_collection. Maybe we could factor + // it, but it's not easy to see whether we could benefit from + // this. (Maybe a variant would be appropriate.) + ast::ChunkList::list_type contents; + for (const ast::ChunkInterface* d : e) + { + d->accept(*this); + // The result can be either an ast::ChunkInterface* or an ast::ChunkList*. + auto chunk = dynamic_cast<ast::ChunkInterface*>(result_); + if (chunk) + contents.emplace_back(chunk); + else + { + auto chunklist = dynamic_cast<ast::ChunkList*>(result_); + if (chunklist) + { + contents.splice(contents.end(), chunklist->chunks_get()); + delete chunklist; + } + else + abort(); + } + } + result_ = new ast::ChunkList(location, contents); + } + + /*-----------------------------. + | Desugar class declarations. | + `-----------------------------*/ + + void DesugarVisitor::desugar_constructor(parse::Tweast& functions, + const type::Class* cls, + misc::symbol class_name) + { + functions << " function " << class_ctor_prefix << class_name + << "() : " + " " + << class_variant_prefix << class_name + << " = " + " let"; + // Initialize each mandatory field of the variant (i.e., + // the fields holding the attributes of the classes and + // its super classes). + for (const type::Class* c = cls; c; c = c->super_get()) + if (c->has_data()) + { + functions << " var contents_" << class_names_(c) << " := " + << " " << class_contents_prefix << class_names_(c) << " { "; + + for (auto a = c->attrs_get().begin(); a != c->attrs_get().end(); a++) + { + if (a != c->attrs_get().begin()) + functions << ", "; + const ast::VarDec* attr; + // FIXME DONE: Some code was deleted here (Initialize attr). + attr = a->def_get(); + misc::symbol attr_name = attr->name_get(); + // Partially clone the contents of the VarDec + // (cloning the whole VarDec would leak memory). + + ast::Exp* attr_init = recurse(attr->init_get()); + // Cast the initialization value if needed. + if (attr->init_get() && attr->type_name_get()) + adapt_type(attr_init, class_type_query(*attr->init_get()), + class_type_query(*attr->type_name_get())); + functions << attr_name << " = " << attr_init; + } + functions << " } "; + } + functions << " in "; + // Create a list of initializations for each field of the + // variant being constructed. + field_inits_type inits; + for (const type::Class* c = cls; c; c = c->super_get()) + if (c->has_data()) + { + // FIXME DONE: Some code was deleted here. + std::string base = "contents_"; + std::string name = class_names_(c); + misc::put(inits, c, base + name); + } + // Create the contents of the variant. + functions << variant_exp(cls, cls, inits) << " end\n"; + } + + void DesugarVisitor::desugar_method(parse::Tweast& functions, + const type::Method* method, + misc::symbol class_name) + { + functions << " function " << method_prefix << class_name << "_" + << method->name_get() << " (self : " << class_variant_prefix + << class_name; + // Get the other arguments. + const ast::MethodDec* def; + // FIXME DONE: Some code was deleted here (Initiliaze def). + def = method->def_get(); + for (const ast::VarDec* arg : def->formals_get()) + functions << ", " << arg->name_get() << " : " + << recurse(*arg->type_name_get()); + functions << ")"; + if (def->result_get()) + functions << " : " << recurse(def->result_get()); + ast::Exp* body = recurse(def->body_get()); + // Cast the return value of the function if needed. + if (def->result_get()) + adapt_type(body, class_type_query(*def->body_get()), + class_type_query(*def->result_get())); + functions << " = " << body << "\n"; + } + + void DesugarVisitor::dispatch_function(parse::Tweast& functions, + const ast::TypeChunk& e, + const type::Class* cls, + const type::Method* method, + misc::symbol class_name, + dispatch_list_type& sub_dispatches) + { + for (const type::Class* c = cls->super_get(); c; c = c->super_get()) + { + // If this class is not defined in the current chunk, then + // the subdispatch method is not needed yet (since it can + // only be called after the declaration of the said class. + if (std::ranges::any_of(e, [c](const ast::TypeDec* t) { + return class_type_query(*t) == c; + })) + continue; + + // Determine if the class c implements our method. If not, + // we do not need to write a sub dispatch method for it. + auto meth_it = std::ranges::find_if( + c->meths_get(), [method](const type::Method* meth) { + return meth->name_get() == method->name_get(); + }); + + if (meth_it == c->meths_get().end()) + continue; + + const type::Method* parent_method = *meth_it; + + // Since we're looping inside a chunk, we do not rebuild an + // already built sub dispatch method. + auto disp_it = sub_dispatches.emplace(c, parent_method); + + if (!disp_it.second) + continue; + + // Increments the dispatch counter. + if (dispatch_map_.find(parent_method) == dispatch_map_.end()) + dispatch_map_[parent_method] = 2; + else + dispatch_map_[parent_method] = dispatch_map_[parent_method] + 1; + + // Keep track of the added dispatch. + dispatch_added_ += parent_method; + + // We build the subdispatch method. + functions << " function " << dispatch_fun_name(c, parent_method) + << " (self : " << class_variant_prefix << class_names_(c); + // Get the other arguments. + const ast::MethodDec* def; + // FIXME DONE: Some code was deleted here (Initialize def). + def = parent_method->def_get(); + for (const ast::VarDec* arg : def->formals_get()) + functions << ", " << arg->name_get() << " : " + << recurse(*arg->type_name_get()); + functions << ")"; + if (def->result_get()) + functions << " : " << recurse(def->result_get()); + functions << " = " << dispatch_switch(c, parent_method, &e, method); + } + + functions << " function " << dispatch_fun_name(cls, method) + << " (self : " << class_variant_prefix << class_name; + // Get the other arguments. + const ast::MethodDec* def; + // FIXME DONE: Some code was deleted here (Initialize def). + def = method->def_get(); + for (const ast::VarDec* arg : def->formals_get()) + functions << ", " << arg->name_get() << " : " + << recurse(*arg->type_name_get()); + functions << ")"; + if (def->result_get() != nullptr) + functions << " : " << recurse(def->result_get()); + functions << " = " << dispatch_switch(cls, method, &e); + } + + void DesugarVisitor::handle_class(const ast::TypeChunk& e, + const type::Class* cls, + parse::Tweast& functions, + dispatch_list_type& sub_dispatches) + { + misc::symbol class_name = class_names_(cls); + + /*---------------------------. + | Introduce a new class id. | + `---------------------------*/ + + class_ids_ << " var " << class_id_prefix << class_name + << " := " << cls->id_get() << "\n"; + + /*----------------------------------------------------. + | Create a record holding the actual class contents. | + `----------------------------------------------------*/ + + if (cls->has_data()) + { + types_ << " type " << class_contents_prefix << class_name << " =" + << " { "; + // FIXME DONE: Some code was deleted here (Populate the record with attributes (names and types)). + const auto& attributes = cls->attrs_get(); + const auto& first = attributes.begin(); + + for (auto attribute = first; attribute != attributes.end(); ++attribute) + { + if (attribute != first) + types_ << ", "; + + types_ << attribute->name_get() << " : " + << type_symbol(&attribute->type_get()); + } + + types_ << " }\n"; + } + + /*--------------------------------------------------------------. + | Create a variant able to store any dynamic type corresponding | + | to this (static) class type. | + `--------------------------------------------------------------*/ + + types_ << " type " << class_variant_prefix << class_name << " =" + << variant_ty(cls); + + /*-----------------------. + | Create a constructor. | + `-----------------------*/ + + desugar_constructor(functions, cls, class_name); + + /*-------------------------------------------------------------. + | Create conversion routines from the class type to any of its | + | super types. | + `-------------------------------------------------------------*/ + + for (const type::Class* super_type = cls->super_get(); super_type; + super_type = super_type->super_get()) + funs_tweast << upcast_function(cls, super_type); + + /*-------------------------------------------------------------. + | Create conversion routines from the class type to any of its | + | subtypes. | + `-------------------------------------------------------------*/ + + for (const type::Class* subclass : cls->subclasses_get()) + functions << downcast_function(cls, subclass); + + for (const type::Method* m : cls->meths_get()) + { + desugar_method(functions, m, class_name); + dispatch_function(functions, e, cls, m, class_name, sub_dispatches); + } + } + + /* All type-related code is emitted into the top-level chunklist, so + that all classes are stored in the same typechunk, allowing them + to see their subclasses and be able to build a variant for each + of them. */ + void DesugarVisitor::operator()(const ast::TypeChunk& e) + { + parse::Tweast functions; + // Is used to know what class/method pair we already have seen for the + // sub dispatch functions. + dispatch_list_type sub_dispatches; + for (const ast::TypeDec* t : e) + { + const type::Class* cls = nullptr; + // FIXME DONE: Some code was deleted here (Get the ty's class type). + cls = class_type_get(t->ty_get()); + + if (cls) + handle_class(e, cls, functions, sub_dispatches); + else + { + /* FIXME: In the rest of the visitor, the + simply-clone-this-node case is handled before the + desugar-this-node case. */ + // Otherwise, clone the type declaration. + ast::TypeDec* typedec = recurse(*t); + assertion(typedec); + types_ << *typedec << '\n'; + } + } + + ast::ChunkList* funs_list = parse::parse(functions); + result_ = funs_list; + } + + /*------------------------------------------------. + | Desugar class instantiations and object usage. | + `------------------------------------------------*/ + + void DesugarVisitor::operator()(const ast::VarDec& e) + { + /* We don't desugar everything using concrete syntax here, because + it would require a lot of additional manipulations, as we + cannot easily produce a single VarDec from a parsing. Also + working from VarChunk (with an `s') doesn't help much either, as + VarDec (with no `s') are also found in FunctionDec. */ + + // If this is not an object instantiation, delegate to the cloner. + + const type::Class* class_type = class_type_query(e); + if (!class_type) + return super_type::operator()(e); + + // Otherwise, handle the different cases. + const ast::Location& location = e.location_get(); + ast::NameTy* type_name = nullptr; + ast::Exp* init = nullptr; + if (e.init_get()) + { + // Object (variable) declaration. + if (e.type_name_get()) + { + type_name = recurse(e.type_name_get()); + init = recurse(e.init_get()); + // If the dynamic type is non-nil and different from the + // static type, cast INIT to the latter. + // FIXME DONE: Some code was deleted here. + if (!init) + { + unreachable(); + } + + const type::Class* name_type = class_type_get(*type_name); + const type::Class* init_type = class_type_get(*init); + if (name_type != init_type) + { + adapt_type(init, name_type, init_type); + } + // Up to here + } + else + // No manifest type: simply clone the declaration as-is. + return super_type::operator()(e); + } + else + // Formal declaration. + type_name = recurse(e.type_name_get()); + + misc::symbol name = e.name_get(); + + result_ = new ast::VarDec(location, name, type_name, init); + postcondition(type_name || init); + } + + // Desugar a class instantiation as a call to the desugared ctor routine. + void DesugarVisitor::operator()(const ast::ObjectExp& e) + { + // FIXME DONE: Some code was deleted here. + const ast::Location location = e.location_get(); + + const std::string class_name = e.type_name_get().name_get(); + + const std::string call_name = class_ctor_prefix + class_name; + const auto args = new ast::exps_type; + result_ = new ast::CallExp(location, call_name, args); + } + + void DesugarVisitor::operator()(const ast::IfExp& e) + { + // FIXME DONE: Some code was deleted here. + ast::Exp* cond = recurse(e.test_get()); + ast::Exp* then_clause = recurse(e.thenclause_get()); + ast::Exp* else_clause = recurse(e.elseclause_get()); + result_ = new ast::IfExp(e.location_get(), cond, then_clause, else_clause); + } + + void DesugarVisitor::operator()(const ast::AssignExp& e) + { + // If this is not an object assignment, delegate to the cloner. + const type::Class* lhs_class_type; + // FIXME DONE: Some code was deleted here. + lhs_class_type = class_type_query(e.var_get()); + + if (!lhs_class_type) + return super_type::operator()(e); + + // Duplicate the subtrees of E. + ast::Var* var = nullptr; + // FIXME DONE: Some code was deleted here (Recurse). + var = recurse(e.var_get()); + + ast::Exp* exp = nullptr; + // FIXME DONE: Some code was deleted here (Recurse). + exp = recurse(e.exp_get()); + + // If the RHS type is non-nil and different from the LHS type, + // cast EXP to the latter. + // FIXME DONE: Some code was deleted here. + const type::Class* rhs_class_type = class_type_get(*exp); + if (lhs_class_type != rhs_class_type) + { + adapt_type(exp, rhs_class_type, lhs_class_type); + } + // Up to here + + ast::Exp* assignment = + parse::parse(parse::Tweast() << var << " := " << exp); + result_ = assignment; + } + + ast::exps_type* DesugarVisitor::recurse_args(const ast::exps_type& actuals, + const type::Record& formals) + { + // For each argument, check the type of the actual argument + // against the formal one. If they are two different class types, + // convert the actual argument to the expected type. + auto args = new ast::exps_type; + ast::exps_type::const_iterator i; + type::Record::const_iterator j; + for (i = actuals.begin(), j = formals.begin(); + i != actuals.end() && j != formals.end(); ++i, ++j) + { + // Clone the argument. + ast::Exp* arg = recurse(**i); + + // In the case of a class, handle the case of a (non-nil) actual + // argument having a different type than the corresponding + // formal. + const type::Type* formal_type = &j->type_get().actual(); + auto formal_class_type = dynamic_cast<const type::Class*>(formal_type); + // FIXME DONE: Some code was deleted here. + // How to check if this arg is non nil ? + // Checking if arg is not a nullptr ? + if (formal_class_type && arg) + { + const type::Type* arg_type = &((*i)->type_get()->actual()); + auto arg_class_type = dynamic_cast<const type::Class*>(arg_type); + adapt_type(arg, arg_class_type, formal_class_type); + } + // Up to here + args->emplace_back(arg); + } + return args; + } + + void DesugarVisitor::operator()(const ast::ArrayExp& e) + { + // We want to allow this: + // let + // class A {} + // class B extends A {} + // type arrtype = array of A + // var arr := arrtype[10] of new B + // in + // arr[0] := new B; + // arr[1] := new A + // end + // FIXME DONE: Some code was deleted here. + + parse::Tweast input; + const type::Type* contener_type = &(e.type_name_get().type_get()->actual()); + const type::Type* init_type = &(e.init_get().type_get()->actual()); + + auto contener_class_type = dynamic_cast<const type::Class*>(contener_type); + auto init_class_type = dynamic_cast<const type::Class*>(init_type); + + ast::Exp* reced = recurse(e.init_get()); + if (contener_class_type && init_class_type && reced) + { + adapt_type(reced, init_class_type, contener_class_type); + } + + result_ = recurse(e); + } + + void DesugarVisitor::operator()(const ast::RecordExp& e) + { + // We want to allow this: + // let + // class A {} + // class B extends A {} + // type rectype = { a : A } + // var rec := rectype { a = new B } + // in + // end + // FIXME DONE: Some code was deleted here. + + const type::Type* rec_type = &(e.type_get()->actual()); + auto actual_rec_type = dynamic_cast<const type::Record*>(rec_type); + + if (actual_rec_type) + { + ast::fieldinits_type::const_iterator i; + type::Record::const_iterator j; + for (i = e.fields_get().begin(), j = actual_rec_type->fields_get().begin(); + i != e.fields_get().end() && j != actual_rec_type->fields_get().end(); + ++i, ++j) + { + const type::Type* given_type = &((*i)->init_get().type_get()->actual()); + const type::Type* asked_type = &j->type_get().actual(); + auto class_given = dynamic_cast<const type::Class*>(given_type); + auto class_asked = dynamic_cast<const type::Class*>(asked_type); + + ast::Exp* reced = recurse((*i)->init_get()); + + if (class_given && class_asked && reced) + { + adapt_type(reced, class_given, class_asked); + } + } + } + + // Maybe need to change this because we may need to create another + result_ = recurse(e); + } + + void DesugarVisitor::operator()(const ast::CallExp& e) + { + const type::Function* function_type; + // FIXME DONE: Some code was deleted here. + const ast::FunctionDec* interm = e.def_get(); + function_type = dynamic_cast<const type::Function*>(interm); + + if (!interm) + { + unreachable(); + } + + const ast::Location& location = e.location_get(); + // FIXME DONE: Some code was deleted here (Grab name). + misc::symbol name = e.name_get(); + + // FIXME DONE: Some code was deleted here (Actual arguments). + const ast::exps_type& arguments = e.args_get(); + + // (Types of) formal arguments. + const type::Record& formals = function_type->formals_get(); + // Desugar the arguments and handle possible polymorphic assignments. + // FIXME DONE: Some code was deleted here. + ast::exps_type* final_args = recurse_args(arguments, formals); + + // FIXME DONE: Some code was deleted here (Instantiate into result). + result_ = new ast::CallExp(location, name, final_args); + } + + /*------------------------------------. + | Desugar accesses to class members. | + `------------------------------------*/ + + void DesugarVisitor::operator()(const ast::FieldVar& e) + { + // Check the type of the variable to see whether it is a class or + // a record. + const type::Class* class_type; + // FIXME DONE: Some code was deleted here. + class_type = class_type_query(e.var_get()); + + // If this is not a class, delegate to the cloner. + if (!class_type) + return super_type::operator()(e); + + // FIXME DONE: Some code was deleted here (Grab name). + misc::symbol name = e.name_get(); + + // Otherwise, desugar this FieldVar as an access to an attribute. + + // Look for the attribute within the class and its base classes. + const type::Class* owner = nullptr; + for (const type::Class* c = class_type; c; c = c->super_get()) + { + // FIXME DONE: Some code was deleted here. + if (c->attr_find(name)) + { + owner = c; + break; + } + } + assertion(owner); + + ast::Var* var; + // FIXME DONE: Some code was deleted here (Recurse). + var = recurse(e.var_get()); + + ast::Exp* attr_var = + parse::parse(parse::Tweast() << var << "." << variant_field_prefix + << class_names_(owner) << "." + // FIXME DONE ??: Some code was deleted here. + << name + ); + result_ = attr_var; + } + + void DesugarVisitor::operator()(const ast::LetExp& e) + { + // Save the current scope situation for dispatched methods + auto saved_dispatch_added_ = dispatch_added_; + dispatch_added_.clear(); + + super_type::operator()(e); + + // After exiting the scope, remove unreachable dispatch methods + for (const auto* meth : dispatch_added_) + { + if (dispatch_map_[meth] == 2) + dispatch_map_.take(meth); + else + dispatch_map_[meth] -= 1; + } + + // Resume the current scope + dispatch_added_ = saved_dispatch_added_; + } + + void DesugarVisitor::operator()(const ast::MethodCallExp& e) + { + const type::Method* method_type; + // FIXME DONE: Some code was deleted here (Initialize method_type). + method_type = dynamic_cast<const type::Method*>(&e.def_get()->type_get()->actual()); + // Maybe we need this ? + if (!method_type) + { + unreachable(); + } + + const type::Class* owner_type = method_type->owner_get(); + + const ast::Location& location = e.location_get(); + std::string name = dispatch_fun_name(owner_type, method_type); + + // FIXME DONE: Some code was deleted here (Fetch actual arguments). + // ??????????????????????????????????????????????????????????? + const ast::exps_type actual_args = e.args_get(); + + // (Types of) formal arguments. + const type::Record& formals = method_type->formals_get(); + // Desugar the arguments and handle possible polymorphic assignements. + ast::exps_type* args; + // FIXME DONE: Some code was deleted here (Initialize args). + args = recurse_args(actual_args, formals); + + // Process the target of the method call, and convert it to the + // expected type if needed. + ast::Exp* object; + // FIXME DONE: Some code was deleted here (Recurse). + object = recurse(e.object_get()); + + // FIXME DONE: Some code was deleted here (Adapt type). + const type::Class* item_type = class_type_query(*object); + adapt_type(object, item_type, owner_type); + // Prepend the target to the actual arguments, as the desugared + // method expects to find it as its first arguments. + args->insert(args->begin(), object); + + // Turn the method call into a function call to the desugared method. + // FIXME DONE: Some code was deleted here (Instanciate into result). + ast::Var* finial = dynamic_cast<ast::Var*>(object); + if (!finial) + { + unreachable(); + } + result_ = new ast::MethodCallExp(location, name, args, finial); + } + + /*--------------------------. + | New types and functions. | + `--------------------------*/ + + // Introduce a desugared builtin Object in the top-level function. + void DesugarVisitor::operator()(const ast::FunctionDec& e) + { + bool is_main; + // FIXME DONE: Some code was deleted here (Setup is_main). + is_main = e.name_get() == "_main"; + if (is_main) + { + // Desugared data structures of the builtin Object. + types_ << " type " << class_variant_prefix + << "Object =" << variant_ty(&type::Class::object_instance()); + // Object's class id. + class_ids_ << " var " << class_id_prefix + << "Object := " + " " + << type::Class::object_instance().id_get(); + } + + // Process E. + super_type::operator()(e); + if (is_main) + { + // Object's ctor. + funs_tweast << " function " << class_ctor_prefix + << "Object() :" + " " + << class_variant_prefix << "Object ="; + // Initialize the variant (a single field is filled, the one + // corresponding to Object). + field_inits_type object_init; + misc::put(object_init, &type::Class::object_instance(), + std::string(class_contents_prefix) + "Object {}"); + // Create the variant. + funs_tweast << variant_exp(&type::Class::object_instance(), + &type::Class::object_instance(), + object_init); + + // Parse the built TWEASTs. + ast::ChunkList* types = parse::parse(types_); + ast::ChunkList* class_ids = parse::parse(class_ids_); + ast::ChunkList* funs = parse::parse(funs_tweast); + // Gather these declarations. + types->splice_back(*class_ids); + types->splice_back(*funs); + // Add them to the top of the program. + auto res = dynamic_cast<ast::FunctionDec*>(result_); + parse::Tweast input; + input << "let " << types << " in " << res->body_get() << " end"; + res->body_set(parse::parse(input)); + } + + // Cast the return value of the function if needed. + if (e.body_get() && e.result_get()) + { + const type::Class* body_type = class_type_query(*e.body_get()); + const type::Class* result_type = class_type_query(*e.result_get()); + if (body_type && result_type && body_type != result_type) + { + auto res = dynamic_cast<ast::FunctionDec*>(result_); + parse::Tweast input; + input << upcast_fun_name(body_type, result_type) << " (" + << res->body_get() << ")"; + res->body_set(parse::parse(input)); + } + } + } + + void DesugarVisitor::operator()(const ast::NameTy& e) + { + // Check if E is the name of a class; if not, just clone it. + const type::Class* class_type = class_type_query(e); + if (!class_type) + return super_type::operator()(e); + + // Otherwise, desugar the name of E. + const ast::Location& location = e.location_get(); + result_ = new ast::NameTy( + location, class_variant_prefix + class_names_(class_type).get()); + } + +} // namespace object |