+ virtual void visit(Assignment &);
+ virtual void visit(TernaryExpression &);
+ virtual void visit(FunctionCall &);
+ virtual void visit(VariableDeclaration &);
+ virtual void visit(Iteration &);
+};
+
+/**
+Breaks aggregates up into separate variables if only the individual fields are
+accessed and not the aggregate as a whole.
+*/
+class AggregateDismantler: public TraversingVisitor
+{
+private:
+ struct AggregateMember
+ {
+ const VariableDeclaration *declaration = 0;
+ unsigned index = 0;
+ RefPtr<Expression> initializer;
+ std::vector<RefPtr<Expression> *> references;
+ };
+
+ struct Aggregate
+ {
+ VariableDeclaration *declaration = 0;
+ Block *decl_scope = 0;
+ NodeList<Statement>::iterator insert_point;
+ std::vector<AggregateMember> members;
+ bool referenced = false;
+ bool members_referenced = false;
+ };
+
+ NodeList<Statement>::iterator insert_point;
+ std::map<Statement *, Aggregate> aggregates;
+ bool composite_reference = false;
+ Assignment::Target r_reference;
+ Aggregate *r_aggregate_ref = 0;
+
+public:
+ bool apply(Stage &);
+
+private:
+ virtual void visit(Block &);
+ virtual void visit(RefPtr<Expression> &);
+ virtual void visit(VariableReference &);
+ void visit_composite(RefPtr<Expression> &);
+ virtual void visit(MemberAccess &);
+ virtual void visit(BinaryExpression &);
+ virtual void visit(StructDeclaration &) { }
+ virtual void visit(VariableDeclaration &);
+ virtual void visit(InterfaceBlock &) { }
+ virtual void visit(FunctionDeclaration &);
+};
+
+/** Replaces expressions consisting entirely of literals with the results of
+evaluating the expression.*/
+class ConstantFolder: private TraversingVisitor
+{
+private:
+ VariableDeclaration *iteration_var = 0;
+ Variant iter_init_value;
+ Variant r_constant_value;
+ bool iteration_init = false;
+ bool r_constant = false;
+ bool r_literal = false;
+ bool r_uses_iter_var = false;
+ bool r_any_folded = false;
+
+public:
+ bool apply(Stage &s) { s.content.visit(*this); return r_any_folded; }
+
+private:
+ template<typename T>
+ static T evaluate_logical(char, T, T);
+ template<typename T>
+ static bool evaluate_relation(const char *, T, T);
+ template<typename T>
+ static T evaluate_arithmetic(char, T, T);
+ template<typename T>
+ static T evaluate_int_special_op(char, T, T);
+ template<typename T>
+ void convert_to_result(const Variant &);
+ void set_result(const Variant &, bool = false);
+
+ virtual void visit(RefPtr<Expression> &);
+ virtual void visit(Literal &);
+ virtual void visit(VariableReference &);