bug fixes for script optimization intermediate forms

auxil/gen-zam

@@ -1 +1 @@
-Subproject commit 16841c95849d4d82f239bfb0c46bc217af368da2
+Subproject commit f62a0215f063bc768d7e85b4a49faeb07ca3cb14

src/Stmt.h

@@ -450,6 +450,7 @@ public:
 	ReturnStmt(ExprPtr e, bool ignored);
 
 	// Optimization-related:
+	bool IsReduced(Reducer* c) const override;
 	StmtPtr DoReduce(Reducer* c) override;
 
 	bool NoFlowAfter(bool ignore_break) const override { return true; }

src/Type.cc

@@ -788,9 +788,12 @@ bool FuncType::CheckArgs(const std::vector<TypePtr>& args, bool is_init, bool do
 	if ( my_args.size() != args.size() )
 		{
 		if ( do_warn )
+			{
 			Warn(util::fmt("Wrong number of arguments for function. Expected %zu, got %zu.",
 			               args.size(), my_args.size()));
-		const_cast<FuncType*>(this)->reported_error = true;
+			const_cast<FuncType*>(this)->reported_error = true;
+			}
+
 		return false;
 		}
 

src/script_opt/Expr.cc

@@ -1851,7 +1851,12 @@ ExprPtr AssignExpr::ReduceToSingleton(Reducer* c, StmtPtr& red_stmt)
 	if ( val )
 		return make_intrusive<ConstExpr>(val);
 
-	return op1->AsRefExprPtr()->GetOp1();
+	auto lhs = op1->AsRefExprPtr()->GetOp1();
+	StmtPtr lhs_stmt;
+	auto new_op1 = lhs->ReduceToSingleton(c, lhs_stmt);
+	red_stmt = MergeStmts(red_stmt, lhs_stmt);
+
+	return new_op1;
 	}
 
 ExprPtr IndexSliceAssignExpr::Duplicate()
@@ -2368,7 +2373,14 @@ bool CallExpr::HasReducedOps(Reducer* c) const
 	if ( ! func->IsSingleton(c) )
 		return NonReduced(this);
 
-	return args->HasReducedOps(c);
+	// We don't use args->HasReducedOps() here because for ListExpr's
+	// the method has some special-casing that isn't germane for calls.
+
+	for ( const auto& expr : args->Exprs() )
+		if ( ! expr->IsSingleton(c) )
+			return false;
+
+	return true;
 	}
 
 ExprPtr CallExpr::Reduce(Reducer* c, StmtPtr& red_stmt)
@@ -2386,9 +2398,7 @@ ExprPtr CallExpr::Reduce(Reducer* c, StmtPtr& red_stmt)
 	if ( ! func->IsSingleton(c) )
 		func = func->ReduceToSingleton(c, red_stmt);
 
-	StmtPtr red2_stmt;
+	StmtPtr red2_stmt = args->ReduceToSingletons(c);
-	// We assume that ListExpr won't transform itself fundamentally.
-	(void)args->Reduce(c, red2_stmt);
 
 	// ### could check here for (1) pure function, and (2) all
 	// arguments constants, and call it to fold right now.
@@ -2558,11 +2568,14 @@ StmtPtr ListExpr::ReduceToSingletons(Reducer* c)
 
 	loop_over_list(exprs, i)
 		{
-		if ( exprs[i]->IsSingleton(c) )
+		auto& e_i = exprs[i];
+
+		if ( e_i->IsSingleton(c) )
 			continue;
 
 		StmtPtr e_stmt;
-		auto old = exprs.replace(i, exprs[i]->Reduce(c, e_stmt).release());
+		auto new_e_i = e_i->ReduceToSingleton(c, e_stmt);
+		auto old = exprs.replace(i, new_e_i.release());
 		Unref(old);
 
 		if ( e_stmt )

src/script_opt/Stmt.cc

@@ -646,21 +646,26 @@ StmtPtr ReturnStmt::Duplicate()
 
 ReturnStmt::ReturnStmt(ExprPtr arg_e, bool ignored) : ExprStmt(STMT_RETURN, std::move(arg_e)) { }
 
+bool ReturnStmt::IsReduced(Reducer* c) const
+	{
+	if ( ! e || e->IsSingleton(c) )
+		return true;
+
+	return NonReduced(e.get());
+	}
+
 StmtPtr ReturnStmt::DoReduce(Reducer* c)
 	{
 	if ( ! e )
 		return ThisPtr();
 
 	if ( c->Optimizing() )
-		{
 		e = c->OptExpr(e);
-		return ThisPtr();
-		}
 
-	if ( ! e->IsSingleton(c) )
+	else if ( ! e->IsSingleton(c) )
 		{
 		StmtPtr red_e_stmt;
-		e = e->Reduce(c, red_e_stmt);
+		e = e->ReduceToSingleton(c, red_e_stmt);
 
 		if ( red_e_stmt )
 			{