Changeset 37273c8 for src/AST

Timestamp:

Nov 28, 2023, 3:01:52 PM (23 months ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

master

Children:

ab9c1b3

Parents:

4bc4b4c

Message:

Removed the old-ast-compatable FunctionDecl constructor. However, enough cases pass nothing polymorphic along some of the uses of the constructor now go to a new monomorphic function constructor.

Location:

src/AST

Files:

• Decl.cpp (modified) (1 diff)
• Decl.hpp (modified) (1 diff)

src/AST/Decl.cpp

@@ -41 +41 @@
 
 FunctionDecl::FunctionDecl( const CodeLocation & loc, const std::string & name,
-        std::vector<ptr<TypeDecl>>&& forall,
         std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
         CompoundStmt * stmts, Storage::Classes storage, Linkage::Spec linkage,
         std::vector<ptr<Attribute>>&& attrs, Function::Specs fs, ArgumentFlag isVarArgs )
-: DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ),
-        type_params(std::move(forall)), assertions(),
-        params(std::move(params)), returns(std::move(returns)), stmts( stmts ) {
-        FunctionType * ftype = new FunctionType( isVarArgs );
-        for (auto & param : this->params) {
-                ftype->params.emplace_back(param->get_type());
-        }
-        for (auto & ret : this->returns) {
-                ftype->returns.emplace_back(ret->get_type());
-        }
-        for (auto & tp : this->type_params) {
-                ftype->forall.emplace_back(new TypeInstType(tp));
-                for (auto & ap: tp->assertions) {
-                        ftype->assertions.emplace_back(new VariableExpr(loc, ap));
-                }
-        }
-        this->type = ftype;
+: FunctionDecl( loc, name, {}, {}, std::move(params), std::move(returns),
+                stmts, storage, linkage, std::move(attrs), fs, isVarArgs ) {
 }
 

src/AST/Decl.hpp

@@ -135 +135 @@
         std::vector< ptr<Expr> > withExprs;
 
-        // The difference between the two constructors is in how they handle
-        // assertions. The first constructor uses the assertions from the type
-        // parameters, in the style of the old ast, and puts them on the type.
-        // The second takes an explicite list of assertions and builds a list of
-        // references to them on the type.
-
-        FunctionDecl( const CodeLocation & loc, const std::string & name, std::vector<ptr<TypeDecl>>&& forall,
+        /// Monomorphic Function Constructor:
+        FunctionDecl( const CodeLocation & locaction, const std::string & name,
                 std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
                 CompoundStmt * stmts, Storage::Classes storage = {}, Linkage::Spec linkage = Linkage::Cforall,
                 std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {}, ArgumentFlag isVarArgs = FixedArgs );
 
+        /// Polymorphic Function Constructor:
         FunctionDecl( const CodeLocation & location, const std::string & name,
                 std::vector<ptr<TypeDecl>>&& forall, std::vector<ptr<DeclWithType>>&& assertions,