+void ExpressionInliner::visit(MemberAccess &memacc)
+{
+ visit_and_record(memacc.left, memacc.oper, false);
+ r_oper = memacc.oper;
+ r_trivial = false;
+}
+
+void ExpressionInliner::visit(Swizzle &swizzle)
+{
+ visit_and_record(swizzle.left, swizzle.oper, false);
+ r_oper = swizzle.oper;
+ r_trivial = false;
+}
+
+void ExpressionInliner::visit(UnaryExpression &unary)
+{
+ SetFlag set_target(mutating, mutating || unary.oper->token[1]=='+' || unary.oper->token[1]=='-');
+ visit_and_record(unary.expression, unary.oper, false);
+ r_oper = unary.oper;
+ r_trivial = false;
+}
+
+void ExpressionInliner::visit(BinaryExpression &binary)
+{
+ visit_and_record(binary.left, binary.oper, false);
+ {
+ SetFlag clear_target(mutating, false);
+ visit_and_record(binary.right, binary.oper, true);
+ }
+ r_oper = binary.oper;
+ r_trivial = false;
+}
+
+void ExpressionInliner::visit(Assignment &assign)
+{
+ {
+ SetFlag set_target(mutating);
+ visit_and_record(assign.left, assign.oper, false);
+ }
+ r_oper = 0;
+ visit_and_record(assign.right, assign.oper, true);
+
+ map<Assignment::Target, ExpressionInfo>::iterator i = expressions.find(assign.target);
+ if(i!=expressions.end())
+ {
+ /* Self-referencing assignments can't be inlined without additional
+ work. Just clear any previous expression. */
+ i->second.expression = (assign.self_referencing ? 0 : assign.right.get());
+ i->second.assign_scope = current_block;
+ i->second.inline_point = 0;
+ i->second.inner_oper = r_oper;
+ i->second.available = true;
+ }
+
+ r_oper = assign.oper;
+ r_trivial = false;
+}
+
+void ExpressionInliner::visit(FunctionCall &call)
+{
+ TraversingVisitor::visit(call);
+ r_oper = 0;
+ r_trivial = false;
+}
+
+void ExpressionInliner::visit(VariableDeclaration &var)
+{
+ r_oper = 0;
+ r_trivial = true;
+ TraversingVisitor::visit(var);
+
+ bool constant = var.constant;
+ if(constant && var.layout)
+ {
+ for(vector<Layout::Qualifier>::const_iterator i=var.layout->qualifiers.begin(); (constant && i!=var.layout->qualifiers.end()); ++i)
+ constant = (i->name!="constant_id");
+ }
+
+ /* Only inline global variables if they're constant and have trivial
+ initializers. Non-constant variables could change in ways which are hard to
+ analyze and non-trivial expressions could be expensive to inline. */
+ if((current_block->parent || (constant && r_trivial)) && var.interface.empty())
+ {
+ ExpressionInfo &info = expressions[&var];
+ /* Assume variables declared in an iteration initialization statement
+ will have their values change throughout the iteration. */
+ info.expression = (iteration_init ? 0 : var.init_expression.get());
+ info.assign_scope = current_block;
+ info.inner_oper = r_oper;
+ info.trivial = r_trivial;
+ }
+}
+
+void ExpressionInliner::visit(Iteration &iter)