more SkSL fuzzer crash fixes

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 507 matching lines @@
 
 std::unique_ptr<InterfaceBlock> IRGenerator::convertInterfaceBlock(const ASTInterfaceBlock& intf) {
     std::shared_ptr<SymbolTable> old = fSymbolTable;
     AutoSymbolTable table(this);
     Modifiers mods = this->convertModifiers(intf.fModifiers);
     std::vector<Type::Field> fields;
     for (size_t i = 0; i < intf.fDeclarations.size(); i++) {
         std::unique_ptr<VarDeclarations> decl = this->convertVarDeclarations(
                                                                          *intf.fDeclarations[i], 
                                                                          Variable::kGlobal_Storage);
+        if (!decl) {
+            return nullptr;
+        }
         for (const auto& var : decl->fVars) {
             fields.push_back(Type::Field(var.fVar->fModifiers, var.fVar->fName, 
                                          &var.fVar->fType));
             if (var.fValue) {
                 fErrors.error(decl->fPosition, 
                               "initializers are not permitted on interface block fields");
             }
             if (var.fVar->fModifiers.fFlags & (Modifiers::kIn_Flag |
                                                Modifiers::kOut_Flag |
                                                Modifiers::kUniform_Flag |
@@ skipping 479 matching lines @@
     } else {
         ASSERT(kind == Type::kVector_Kind || kind == Type::kMatrix_Kind);
         int actual = 0;
         for (size_t i = 0; i < args.size(); i++) {
             if (args[i]->fType.kind() == Type::kVector_Kind || 
                 args[i]->fType.kind() == Type::kMatrix_Kind) {
                 int columns = args[i]->fType.columns();
                 int rows = args[i]->fType.rows();
                 args[i] = this->coerce(std::move(args[i]), 
                                        type.componentType().toCompound(fContext, columns, rows));
+                if (!args[i]) {
+                    return nullptr;
+                }
                 actual += args[i]->fType.rows() * args[i]->fType.columns();
             } else if (args[i]->fType.kind() == Type::kScalar_Kind) {
                 actual += 1;
                 if (type.kind() != Type::kScalar_Kind) {
                     args[i] = this->coerce(std::move(args[i]), type.componentType());
+                    if (!args[i]) {
+                        return nullptr;
+                    }
                 }
             } else {
                 fErrors.error(position, "'" + args[i]->fType.description() + "' is not a valid "
                                         "parameter to '" + type.description() + "' constructor");
                 return nullptr;
             }
         }
         int min = type.rows() * type.columns();
         int max = type.columns() > 1 ? INT_MAX : min;
         if ((actual < min || actual > max) &&
@@ skipping 179 matching lines @@
                 return this->convertIndex(std::move(base), *expr);
             } else if (base->fKind == Expression::kTypeReference_Kind) {
                 const Type& oldType = ((TypeReference&) *base).fValue;
                 Type* newType = new Type(oldType.name() + "[]", Type::kArray_Kind, oldType, 
                                          -1);
                 fSymbolTable->takeOwnership(newType);
                 return std::unique_ptr<Expression>(new TypeReference(fContext, base->fPosition, 
                                                                      *newType));
             } else {
                 fErrors.error(expression.fPosition, "'[]' must follow a type name");
+                return nullptr;
             }
         }
         case ASTSuffix::kCall_Kind: {
             auto rawArguments = &((ASTCallSuffix&) *expression.fSuffix).fArguments;
             std::vector<std::unique_ptr<Expression>> arguments;
             for (size_t i = 0; i < rawArguments->size(); i++) {
                 std::unique_ptr<Expression> converted = 
                         this->convertExpression(*(*rawArguments)[i]);
                 if (!converted) {
                     return nullptr;
@@ skipping 94 matching lines @@
         case Expression::kIndex_Kind:
             this->markWrittenTo(*((IndexExpression&) expr).fBase);
             break;
         default:
             fErrors.error(expr.fPosition, "cannot assign to '" + expr.description() + "'");
             break;
     }
 }
 
 }