Turned on SkSL->GLSL compiler

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 171 matching lines @@
         auto var = std::unique_ptr<Variable>(new Variable(decl.fPosition, modifiers, varDecl.fName, 
                                                           *type, storage));
         std::unique_ptr<Expression> value;
         if (varDecl.fValue) {
             value = this->convertExpression(*varDecl.fValue);
             if (!value) {
                 return nullptr;
             }
             value = this->coerce(std::move(value), *type);
         }
-        if ("gl_FragCoord" == varDecl.fName && (*fSymbolTable)[varDecl.fName]) {
+        if ("sk_FragColor" == varDecl.fName && (*fSymbolTable)[varDecl.fName]) {
+            // already defined, ignore
+        } else if ((*fSymbolTable)[varDecl.fName] && 
+                   (*fSymbolTable)[varDecl.fName]->fKind == Symbol::kVariable_Kind && 
+                   ((Variable*) (*fSymbolTable)[varDecl.fName])->fModifiers.fLayout.fBuiltin >= 0) {
             // already defined, just update the modifiers
             Variable* old = (Variable*) (*fSymbolTable)[varDecl.fName];
             old->fModifiers = var->fModifiers;
         } else {
             variables.emplace_back(var.get(), std::move(sizes), std::move(value));
             fSymbolTable->add(varDecl.fName, std::move(var));
         }
     }
     return std::unique_ptr<VarDeclarations>(new VarDeclarations(decl.fPosition, 
                                                                 baseType,
                                                                 std::move(variables)));
 }
 
+std::unique_ptr<ModifiersDeclaration> IRGenerator::convertModifiersDeclaration(
+                                                                 const ASTModifiersDeclaration& m) {
+    Modifiers modifiers = this->convertModifiers(m.fModifiers);
+    return std::unique_ptr<ModifiersDeclaration>(new ModifiersDeclaration(modifiers));
+}
+
 std::unique_ptr<Statement> IRGenerator::convertIf(const ASTIfStatement& s) {
     std::unique_ptr<Expression> test = this->coerce(this->convertExpression(*s.fTest), 
                                                     *fContext.fBool_Type);
     if (!test) {
         return nullptr;
     }
     std::unique_ptr<Statement> ifTrue = this->convertStatement(*s.fIfTrue);
     if (!ifTrue) {
         return nullptr;
     }
@@ skipping 196 matching lines @@
                         FunctionDeclaration newDecl(f.fPosition, f.fName, parameters, *returnType);
                         fErrors.error(f.fPosition, "functions '" + newDecl.description() +
                                                    "' and '" + other->description() + 
                                                    "' differ only in return type");
                         return nullptr;
                     }
                     decl = other;
                     for (size_t i = 0; i < parameters.size(); i++) {
                         if (parameters[i]->fModifiers != other->fParameters[i]->fModifiers) {
                             fErrors.error(f.fPosition, "modifiers on parameter " + 
-                                                       to_string(i + 1) + " differ between " +
-                                                       "declaration and definition");
+                                                       to_string((uint64_t) i + 1) + 
+                                                       " differ between declaration and "
+                                                       "definition");
                             return nullptr;
                         }
                     }
                     if (other->fDefined) {
                         fErrors.error(f.fPosition, "duplicate definition of " + 
                                                    other->description());
                     }
                     break;
                 }
             }
@@ skipping 175 matching lines @@
         return nullptr;
     }
     if (type.kind() == Type::kScalar_Kind) {
         std::vector<std::unique_ptr<Expression>> args;
         args.push_back(std::move(expr));
         ASTIdentifier id(Position(), type.description());
         std::unique_ptr<Expression> ctor = this->convertIdentifier(id);
         ASSERT(ctor);
         return this->call(Position(), std::move(ctor), std::move(args));
     }
-    ABORT("cannot coerce %s to %s", expr->fType.description().c_str(), 
-          type.description().c_str());
+    std::vector<std::unique_ptr<Expression>> args;
+    args.push_back(std::move(expr));
+    return std::unique_ptr<Expression>(new Constructor(Position(), type, std::move(args)));
 }
 
 static bool is_matrix_multiply(const Type& left, const Type& right) {
     if (left.kind() == Type::kMatrix_Kind) {
         return right.kind() == Type::kMatrix_Kind || right.kind() == Type::kVector_Kind;
     }
     return left.kind() == Type::kVector_Kind && right.kind() == Type::kMatrix_Kind;
 }
 /**
  * Determines the operand and result types of a binary expression. Returns true if the expression is
@@ skipping 194 matching lines @@
                                                              std::move(test),
                                                              std::move(ifTrue), 
                                                              std::move(ifFalse)));
 }
 
 std::unique_ptr<Expression> IRGenerator::call(Position position, 
                                               const FunctionDeclaration& function, 
                                               std::vector<std::unique_ptr<Expression>> arguments) {
     if (function.fParameters.size() != arguments.size()) {
         std::string msg = "call to '" + function.fName + "' expected " + 
-                                 to_string(function.fParameters.size()) + 
+                                 to_string((uint64_t) function.fParameters.size()) + 
                                  " argument";
         if (function.fParameters.size() != 1) {
             msg += "s";
         }
-        msg += ", but found " + to_string(arguments.size());
+        msg += ", but found " + to_string((uint64_t) arguments.size());
         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);
         if (arguments[i] && (function.fParameters[i]->fModifiers.fFlags & Modifiers::kOut_Flag)) {
             this->markWrittenTo(*arguments[i]);
         }
     }
     return std::unique_ptr<FunctionCall>(new FunctionCall(position, function,
@@ skipping 63 matching lines @@
     }
     return this->call(position, *ref->fFunctions[0], std::move(arguments));
 }
 
 std::unique_ptr<Expression> IRGenerator::convertConstructor(
                                                     Position position, 
                                                     const Type& type, 
                                                     std::vector<std::unique_ptr<Expression>> args) {
     // FIXME: add support for structs and arrays
     Type::Kind kind = type.kind();
-    if (!type.isNumber() && kind != Type::kVector_Kind && kind != Type::kMatrix_Kind) {
+    if (!type.isNumber() && kind != Type::kVector_Kind && kind != Type::kMatrix_Kind && 
+        kind != Type::kArray_Kind) {
         fErrors.error(position, "cannot construct '" + type.description() + "'");
         return nullptr;
     }
     if (type == *fContext.fFloat_Type && args.size() == 1 && 
         args[0]->fKind == Expression::kIntLiteral_Kind) {
         int64_t value = ((IntLiteral&) *args[0]).fValue;
         return std::unique_ptr<Expression>(new FloatLiteral(fContext, position, (double) value));
     }
     if (args.size() == 1 && args[0]->fType == type) {
         // argument is already the right type, just return it
         return std::move(args[0]);
     }
     if (type.isNumber()) {
         if (args.size() != 1) {
             fErrors.error(position, "invalid arguments to '" + type.description() + 
                                     "' constructor, (expected exactly 1 argument, but found " +
-                                    to_string(args.size()) + ")");
+                                    to_string((uint64_t) args.size()) + ")");
         }
         if (args[0]->fType == *fContext.fBool_Type) {
             std::unique_ptr<IntLiteral> zero(new IntLiteral(fContext, position, 0));
             std::unique_ptr<IntLiteral> one(new IntLiteral(fContext, position, 1));
             return std::unique_ptr<Expression>(
                                          new TernaryExpression(position, std::move(args[0]),
                                                                this->coerce(std::move(one), type),
                                                                this->coerce(std::move(zero), 
                                                                             type)));
         } else if (!args[0]->fType.isNumber()) {
             fErrors.error(position, "invalid argument to '" + type.description() + 
                                     "' constructor (expected a number or bool, but found '" +
                                     args[0]->fType.description() + "')");
         }
+        if (args[0]->fKind == Expression::kIntLiteral_Kind && (type == *fContext.fInt_Type || 
+            type == *fContext.fUInt_Type)) {
+            return std::unique_ptr<Expression>(new IntLiteral(fContext, 
+                                                              position, 
+                                                              ((IntLiteral&) *args[0]).fValue,
+                                                              &type));
+        }
+    } else if (kind == Type::kArray_Kind) {
+        const Type& base = type.componentType();
+        for (size_t i = 0; i < args.size(); i++) {
+            args[i] = this->coerce(std::move(args[i]), base);
+        }
     } 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));
@@ skipping 64 matching lines @@
             break;
         case Token::MINUSMINUS: 
             if (!base->fType.isNumber()) {
                 fErrors.error(expression.fPosition, 
                               "'" + Token::OperatorName(expression.fOperator) + 
                               "' cannot operate on '" + base->fType.description() + "'");
                 return nullptr;
             }
             this->markWrittenTo(*base);
             break;
-        case Token::NOT:
+        case Token::LOGICALNOT:
             if (base->fType != *fContext.fBool_Type) {
                 fErrors.error(expression.fPosition, 
                               "'" + Token::OperatorName(expression.fOperator) + 
                               "' cannot operate on '" + base->fType.description() + "'");
                 return nullptr;
             }
             break;
+        case Token::BITWISENOT:
+            if (base->fType != *fContext.fInt_Type) {
+                fErrors.error(expression.fPosition, 
+                              "'" + Token::OperatorName(expression.fOperator) + 
+                              "' cannot operate on '" + base->fType.description() + "'");
+                return nullptr;
+            }
+            break;
         default: 
             ABORT("unsupported prefix operator\n");
     }
     return std::unique_ptr<Expression>(new PrefixExpression(expression.fOperator, 
                                                             std::move(base)));
 }
 
 std::unique_ptr<Expression> IRGenerator::convertIndex(std::unique_ptr<Expression> base,
                                                       const ASTExpression& index) {
-    if (base->fType.kind() != Type::kArray_Kind && base->fType.kind() != Type::kMatrix_Kind) {
+    if (base->fType.kind() != Type::kArray_Kind && base->fType.kind() != Type::kMatrix_Kind &&
+            base->fType.kind() != Type::kVector_Kind) {
         fErrors.error(base->fPosition, "expected array, but found '" + base->fType.description() + 
                                        "'");
         return nullptr;
     }
     std::unique_ptr<Expression> converted = this->convertExpression(index);
     if (!converted) {
         return nullptr;
     }
-    converted = this->coerce(std::move(converted), *fContext.fInt_Type);
-    if (!converted) {
-        return nullptr;
+    if (converted->fType != *fContext.fUInt_Type) {
+        converted = this->coerce(std::move(converted), *fContext.fInt_Type);
+        if (!converted) {
+            return nullptr;
+        }
     }
     return std::unique_ptr<Expression>(new IndexExpression(fContext, std::move(base), 
                                                            std::move(converted)));
 }
 
 std::unique_ptr<Expression> IRGenerator::convertField(std::unique_ptr<Expression> base,
                                                       const std::string& field) {
     auto fields = base->fType.fields();
     for (size_t i = 0; i < fields.size(); i++) {
         if (fields[i].fName == field) {
@@ skipping 57 matching lines @@
     return std::unique_ptr<Expression>(new Swizzle(fContext, std::move(base), swizzleComponents));
 }
 
 std::unique_ptr<Expression> IRGenerator::convertSuffixExpression(
                                                             const ASTSuffixExpression& expression) {
     std::unique_ptr<Expression> base = this->convertExpression(*expression.fBase);
     if (!base) {
         return nullptr;
     }
     switch (expression.fSuffix->fKind) {
-        case ASTSuffix::kIndex_Kind:
-            return this->convertIndex(std::move(base), 
-                                      *((ASTIndexSuffix&) *expression.fSuffix).fExpression);
+        case ASTSuffix::kIndex_Kind: {
+            const ASTExpression* expr = ((ASTIndexSuffix&) *expression.fSuffix).fExpression.get();
+            if (expr) {
+                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");
+            }
+        }
         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;
                 }
                 arguments.push_back(std::move(converted));
@@ skipping 92 matching lines @@
         case Expression::kIndex_Kind:
             this->markWrittenTo(*((IndexExpression&) expr).fBase);
             break;
         default:
             fErrors.error(expr.fPosition, "cannot assign to '" + expr.description() + "'");
             break;
     }
 }
 
 }