Reduced skslc memory consumption

src/sksl/SkSLIRGenerator.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
  
 #include "SkSLIRGenerator.h"
 
 #include "limits.h"
@@ skipping 353 matching lines @@
     } else {
         fErrors.error(c.fPosition, "continue statement must be inside a loop");
         return nullptr;
     }
 }
 
 std::unique_ptr<Statement> IRGenerator::convertDiscard(const ASTDiscardStatement& d) {
     return std::unique_ptr<Statement>(new DiscardStatement(d.fPosition));
 }
 
-static const Type& expand_generics(const Type& type, int i) {
-    if (type.kind() == Type::kGeneric_Kind) {
-        return *type.coercibleTypes()[i];
-    }
-    return type;
-}
-
-static void expand_generics(const FunctionDeclaration& decl, 
-                            std::shared_ptr<SymbolTable> symbolTable) {
-    for (int i = 0; i < 4; i++) {
-        const Type& returnType = expand_generics(decl.fReturnType, i);
-        std::vector<const Variable*> parameters;
-        for (const auto& p : decl.fParameters) {
-            Variable* var = new Variable(p->fPosition, Modifiers(p->fModifiers), p->fName,
-                                         expand_generics(p->fType, i),
-                                         Variable::kParameter_Storage);
-            symbolTable->takeOwnership(var);
-            parameters.push_back(var);
-        }
-        symbolTable->add(decl.fName, std::unique_ptr<FunctionDeclaration>(new FunctionDeclaration(
-                                                                           decl.fPosition,
-                                                                           decl.fName,
-                                                                           std::move(parameters),
-                                                                           std::move(returnType))));
-    }
-}
-
 std::unique_ptr<FunctionDefinition> IRGenerator::convertFunction(const ASTFunction& f) {
-    bool isGeneric;
     const Type* returnType = this->convertType(*f.fReturnType);
     if (!returnType) {
         return nullptr;
     }
-    isGeneric = returnType->kind() == Type::kGeneric_Kind;
     std::vector<const Variable*> parameters;
     for (const auto& param : f.fParameters) {
         const Type* type = this->convertType(*param->fType);
         if (!type) {
             return nullptr;
         }
         for (int j = (int) param->fSizes.size() - 1; j >= 0; j--) {
             int size = param->fSizes[j];
             std::string name = type->name() + "[" + to_string(size) + "]";
             Type* newType = new Type(std::move(name), Type::kArray_Kind, *type, size);
             fSymbolTable->takeOwnership(newType);
             type = newType;
         }
         std::string name = param->fName;
         Modifiers modifiers = this->convertModifiers(param->fModifiers);
         Position pos = param->fPosition;
         Variable* var = new Variable(pos, modifiers, std::move(name), *type,
                                      Variable::kParameter_Storage);
         fSymbolTable->takeOwnership(var);
         parameters.push_back(var);
-        isGeneric |= type->kind() == Type::kGeneric_Kind;
     }
 
     // find existing declaration
     const FunctionDeclaration* decl = nullptr;
     auto entry = (*fSymbolTable)[f.fName];
     if (entry) {
         std::vector<const FunctionDeclaration*> functions;
         switch (entry->fKind) {
             case Symbol::kUnresolvedFunction_Kind:
                 functions = ((UnresolvedFunction*) entry)->fFunctions;
@@ skipping 37 matching lines @@
                         fErrors.error(f.fPosition, "duplicate definition of " + 
                                                    other->description());
                     }
                     break;
                 }
             }
         }
     }
     if (!decl) {
         // couldn't find an existing declaration
-        if (isGeneric) {
-            ASSERT(!f.fBody);
-            expand_generics(FunctionDeclaration(f.fPosition, f.fName, parameters, *returnType), 
-                            fSymbolTable);
-        } else {
-            auto newDecl = std::unique_ptr<FunctionDeclaration>(new FunctionDeclaration(
-                                                                                     f.fPosition, 
-                                                                                     f.fName, 
-                                                                                     parameters, 
-                                                                                     *returnType));
-            decl = newDecl.get();
-            fSymbolTable->add(decl->fName, std::move(newDecl));
-        }
+        auto newDecl = std::unique_ptr<FunctionDeclaration>(new FunctionDeclaration(f.fPosition,
+                                                                                    f.fName,
+                                                                                    parameters,
+                                                                                    *returnType));
+        decl = newDecl.get();
+        fSymbolTable->add(decl->fName, std::move(newDecl));
     }
     if (f.fBody) {
         ASSERT(!fCurrentFunction);
         fCurrentFunction = decl;
         decl->fDefined = true;
         std::shared_ptr<SymbolTable> old = fSymbolTable;
         AutoSymbolTable table(this);
         for (size_t i = 0; i < parameters.size(); i++) {
             fSymbolTable->addWithoutOwnership(parameters[i]->fName, decl->fParameters[i]);
         }
@@ skipping 399 matching lines @@
         std::string msg = "call to '" + function.fName + "' expected " + 
                                  to_string((uint64_t) function.fParameters.size()) + 
                                  " argument";
         if (function.fParameters.size() != 1) {
             msg += "s";
         }
         msg += ", but found " + to_string((uint64_t) arguments.size());
         fErrors.error(position, msg);
         return nullptr;
     }
+    std::vector<const Type*> types;
+    const Type* returnType;
+    if (!function.determineFinalTypes(arguments, &types, &returnType)) {
+        std::string msg = "no match for " + function.fName + "(";
+        std::string separator = "";
+        for (size_t i = 0; i < arguments.size(); i++) {
+            msg += separator;
+            separator = ", ";
+            msg += arguments[i]->fType.description();
+        }
+        msg += ")";
+        fErrors.error(position, msg);
+        return nullptr;
+    }
     for (size_t i = 0; i < arguments.size(); i++) {
-        arguments[i] = this->coerce(std::move(arguments[i]), function.fParameters[i]->fType);
+        arguments[i] = this->coerce(std::move(arguments[i]), *types[i]);
         if (!arguments[i]) {
             return nullptr;
         }
         if (arguments[i] && (function.fParameters[i]->fModifiers.fFlags & Modifiers::kOut_Flag)) {
             this->markWrittenTo(*arguments[i]);
         }
     }
-    return std::unique_ptr<FunctionCall>(new FunctionCall(position, function,
+    return std::unique_ptr<FunctionCall>(new FunctionCall(position, *returnType, function,
                                                           std::move(arguments)));
 }
 
 /**
  * Determines the cost of coercing the arguments of a function to the required types. Returns true 
  * if the cost could be computed, false if the call is not valid. Cost has no particular meaning 
  * other than "lower costs are preferred".
  */
 bool IRGenerator::determineCallCost(const FunctionDeclaration& function, 
                                     const std::vector<std::unique_ptr<Expression>>& arguments,
                                     int* outCost) {
     if (function.fParameters.size() != arguments.size()) {
         return false;
     }
     int total = 0;
+    std::vector<const Type*> types;
+    const Type* ignored;
+    if (!function.determineFinalTypes(arguments, &types, &ignored)) {
+        return false;
+    }
     for (size_t i = 0; i < arguments.size(); i++) {
         int cost;
-        if (arguments[i]->fType.determineCoercionCost(function.fParameters[i]->fType, &cost)) {
+        if (arguments[i]->fType.determineCoercionCost(*types[i], &cost)) {
             total += cost;
         } else {
             return false;
         }
     }
     *outCost = total;
     return true;
 }
 
 std::unique_ptr<Expression> IRGenerator::call(Position position, 
@@ skipping 420 matching lines @@
         case Expression::kIndex_Kind:
             this->markWrittenTo(*((IndexExpression&) expr).fBase);
             break;
         default:
             fErrors.error(expr.fPosition, "cannot assign to '" + expr.description() + "'");
             break;
     }
 }
 
 }