Changeset 81da3da4 for src/AST

Timestamp:

Dec 11, 2023, 4:18:13 AM (23 months ago)

Author:

JiadaL <j82liang@…>

Branches:

master

Children:

21ce2c7, 2554f24

Parents:

5ddb8bf (diff), 1c85ffc (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

src/AST

Files:

• Chain.hpp (modified) (1 diff)
• Decl.cpp (modified) (2 diffs)
• Decl.hpp (modified) (2 diffs)
• Expr.cpp (modified) (2 diffs)
• Expr.hpp (modified) (5 diffs)

src/AST/Chain.hpp

@@ -33 +33 @@
         template<typename actual_node_t, typename child_t>
         auto operator()( child_t actual_node_t::*child ) {
-                auto n = mutate(base.get());
+                node_t * n = base.get_and_mutate();
                 actual_node_t * node = strict_dynamic_cast<actual_node_t *>(n);
-                base = node;
                 return _chain_mutator< typename std::remove_reference< decltype(node->*child) >::type >{node->*child};
         }
 
         node_t * operator->() {
-                auto n = mutate(base.get());
-                base = n;
-                return n;
+                return base.get_and_mutate();
         }
 };

src/AST/Decl.cpp

@@ -21 +21 @@
 
 #include "Common/Eval.h"       // for eval
+#include "Common/SemanticError.h"
 
 #include "Fwd.hpp"             // for UniqueId
@@ -41 +42 @@
 
 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

@@ -30 +30 @@
 #include "Visitor.hpp"
 #include "Common/utility.h"
-#include "Common/SemanticError.h"                                               // error_str
 
 // Must be included in *all* AST classes; should be #undef'd at the end of the file
@@ -135 +134 @@
         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,

src/AST/Expr.cpp

@@ -222 +222 @@
 }
 
-MemberExpr::MemberExpr( const CodeLocation & loc, const DeclWithType * mem, const Expr * agg,
-    MemberExpr::NoOpConstruction overloadSelector )
-: Expr( loc ), member( mem ), aggregate( agg ) {
-        assert( member );
-        assert( aggregate );
-        assert( aggregate->result );
-        (void) overloadSelector;
-}
-
 bool MemberExpr::get_lvalue() const {
         // This is actually wrong by C, but it works with our current set-up.
@@ -388 +379 @@
         stmts.emplace_back( new ExprStmt{ loc, tupleExpr } );
         stmtExpr = new StmtExpr{ loc, new CompoundStmt{ loc, std::move(stmts) } };
-}
-
-TupleAssignExpr::TupleAssignExpr(
-        const CodeLocation & loc, const Type * result, const StmtExpr * s )
-: Expr( loc, result ), stmtExpr() {
-        stmtExpr = s;
 }
 

src/AST/Expr.hpp

@@ -35 +35 @@
         template<typename node_t> friend node_t * shallowCopy(const node_t * node);
 
-
-class ConverterOldToNew;
-class ConverterNewToOld;
-
 namespace ast {
 
@@ -439 +435 @@
         MemberExpr * clone() const override { return new MemberExpr{ *this }; }
         MUTATE_FRIEND
-
-        // Custructor overload meant only for AST conversion
-        enum NoOpConstruction { NoOpConstructionChosen };
-        MemberExpr( const CodeLocation & loc, const DeclWithType * mem, const Expr * agg,
-            NoOpConstruction overloadSelector );
-        friend class ::ConverterOldToNew;
-        friend class ::ConverterNewToOld;
 };
 
@@ -458 +447 @@
         ConstantExpr(
                 const CodeLocation & loc, const Type * ty, const std::string & r,
-                        std::optional<unsigned long long> i )
-        : Expr( loc, ty ), rep( r ), ival( i ), underlyer(ty) {}
+                        const std::optional<unsigned long long> & i )
+        : Expr( loc, ty ), rep( r ), ival( i ) {}
 
         /// Gets the integer value of this constant, if one is appropriate to its type.
@@ -483 +472 @@
 
         std::optional<unsigned long long> ival;
-
-        // Intended only for legacy support of roundtripping the old AST.
-        // Captures the very-locally inferred type, before the resolver modifies the type of this ConstantExpression.
-        // In the old AST it's constExpr->constant.type
-        ptr<Type> underlyer;
-        friend class ::ConverterOldToNew;
-        friend class ::ConverterNewToOld;
 };
 
@@ -779 +761 @@
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
 
-        friend class ::ConverterOldToNew;
-
 private:
         TupleAssignExpr * clone() const override { return new TupleAssignExpr{ *this }; }
-    TupleAssignExpr( const CodeLocation & loc, const Type * result, const StmtExpr * s );
-
         MUTATE_FRIEND
 };