re-re-land of skslc now automatically turns on derivatives support

src/sksl/SkSLGLSLCodeGenerator.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 "SkSLGLSLCodeGenerator.h"
 
 #include "string.h"
@@ skipping 132 matching lines @@
     this->fFunctionHeader += "    " + absExpr.fType.name() + " " + tmpVar1 + ";\n";
     this->fFunctionHeader += "    " + otherExpr.fType.name() + " " + tmpVar2 + ";\n";
     this->write("((" + tmpVar1 + " = ");
     this->writeExpression(absExpr, kTopLevel_Precedence);
     this->write(") < (" + tmpVar2 + " = ");
     this->writeExpression(otherExpr, kAssignment_Precedence);
     this->write(") ? " + tmpVar1 + " : " + tmpVar2 + ")");
 }
 
 void GLSLCodeGenerator::writeFunctionCall(const FunctionCall& c) {
-    if (!fCaps.fCanUseMinAndAbsTogether && c.fFunction.fName == "min") {
+    if (!fCaps.fCanUseMinAndAbsTogether && c.fFunction.fName == "min" && c.fFunction.fBuiltin) {
         ASSERT(c.fArguments.size() == 2);
         if (is_abs(*c.fArguments[0])) {
             this->writeMinAbsHack(*c.fArguments[0], *c.fArguments[1]);
             return;
         }
         if (is_abs(*c.fArguments[1])) {
             // note that this violates the GLSL left-to-right evaluation semantics. I doubt it will
             // ever end up mattering, but it's worth calling out.
             this->writeMinAbsHack(*c.fArguments[1], *c.fArguments[0]);
             return;
         }
     }
     if (fCaps.fMustForceNegatedAtanParamToFloat && c.fFunction.fName == "atan" && 
-        c.fArguments.size() == 2 && c.fArguments[1]->fKind == Expression::kPrefix_Kind) {
+        c.fFunction.fBuiltin && c.fArguments.size() == 2 && 
+        c.fArguments[1]->fKind == Expression::kPrefix_Kind) {
         const PrefixExpression& p = (PrefixExpression&) *c.fArguments[1];
         if (p.fOperator == Token::MINUS) {
             this->write("atan(");
             this->writeExpression(*c.fArguments[0], kSequence_Precedence);
             this->write(", -1.0 * ");
             this->writeExpression(*p.fOperand, kMultiplicative_Precedence);
             this->write(")");
             return;
         }
     }
+    if (!fFoundDerivatives && fCaps.fShaderDerivativeExtensionString != "" && 
+        (c.fFunction.fName == "dFdx" || c.fFunction.fName == "dFdy") && c.fFunction.fBuiltin) {
+        ASSERT(fCaps.fShaderDerivativeSupport);
+        fHeader << "#extension " << fCaps.fShaderDerivativeExtensionString << " : require\n";
+        fFoundDerivatives = true;
+    }
     this->write(c.fFunction.fName + "(");
     const char* separator = "";
     for (const auto& arg : c.fArguments) {
         this->write(separator);
         separator = ", ";
         this->writeExpression(*arg, kSequence_Precedence);
     }
     this->write(")");
 }
 
@@ skipping 383 matching lines @@
     this->write("return");
     if (r.fExpression) {
         this->write(" ");
         this->writeExpression(*r.fExpression, kTopLevel_Precedence);
     }
     this->write(";");
 }
 
 void GLSLCodeGenerator::generateCode(const Program& program, std::ostream& out) {
     ASSERT(fOut == nullptr);
-    fOut = &out;
+    fOut = &fHeader;
     fProgramKind = program.fKind;
     this->write("#version " + to_string(fCaps.fVersion));
     if (fCaps.fStandard == GLCaps::kGLES_Standard && fCaps.fVersion >= 300) {
         this->write(" es");
     } else if (fCaps.fIsCoreProfile) {
         this->write(" core");
     }
     this->writeLine();
     for (const auto& e : program.fElements) {
         if (e->fKind == ProgramElement::kExtension_Kind) {
             this->writeExtension((Extension&) *e);
         }
     }
+    std::stringstream body;
+    fOut = &body;
     if (fCaps.fStandard == GLCaps::kGLES_Standard) {
         this->write("precision ");
         switch (program.fDefaultPrecision) {
             case Modifiers::kLowp_Flag:
                 this->write("lowp");
                 break;
             case Modifiers::kMediump_Flag:
                 this->write("mediump");
                 break;
             case Modifiers::kHighp_Flag:
@@ skipping 37 matching lines @@
             case ProgramElement::kModifiers_Kind:
                 this->writeModifiers(((ModifiersDeclaration&) *e).fModifiers, true);
                 this->writeLine(";");
                 break;
             default:
                 printf("%s\n", e->description().c_str());
                 ABORT("unsupported program element");
         }
     }
     fOut = nullptr;
+
+    out << fHeader.str();
+    out << body.str();
 }
 
 }