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

src/sksl/SkSLCompiler.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 "SkSLCompiler.h"
 
 #include <fstream>
 #include <streambuf>
 
 #include "ast/SkSLASTPrecision.h"
 #include "SkSLCFGGenerator.h"
 #include "SkSLIRGenerator.h"
 #include "SkSLParser.h"
 #include "SkSLSPIRVCodeGenerator.h"
 #include "ir/SkSLExpression.h"
 #include "ir/SkSLIntLiteral.h"
 #include "ir/SkSLModifiersDeclaration.h"
 #include "ir/SkSLSymbolTable.h"
+#include "ir/SkSLUnresolvedFunction.h"
 #include "ir/SkSLVarDeclarations.h"
 #include "SkMutex.h"
 
 #define STRINGIFY(x) #x
 
 // include the built-in shader symbols as static strings
 
 static const char* SKSL_INCLUDE =
 #include "sksl.include"
 ;
@@ skipping 96 matching lines @@
     ADD_TYPE(Sampler2DRectShadow);
     ADD_TYPE(Sampler1DArrayShadow);
     ADD_TYPE(Sampler2DArrayShadow);
     ADD_TYPE(SamplerCubeArrayShadow);
     ADD_TYPE(GSampler2DArrayShadow);
     ADD_TYPE(GSamplerCubeArrayShadow);
 
     Modifiers::Flag ignored1;
     std::vector<std::unique_ptr<ProgramElement>> ignored2;
     this->internalConvertProgram(SKSL_INCLUDE, &ignored1, &ignored2);
+    fIRGenerator->fSymbolTable->markAllFunctionsBuiltin();
     ASSERT(!fErrorCount);
 }
 
 Compiler::~Compiler() {
     delete fIRGenerator;
 }
 
 // add the definition created by assigning to the lvalue to the definition set
 void Compiler::addDefinition(const Expression* lvalue, const Expression* expr,
                            std::unordered_map<const Variable*, const Expression*>* definitions) {
@@ skipping 238 matching lines @@
     std::vector<std::unique_ptr<ProgramElement>> elements;
     Modifiers::Flag ignored;
     switch (kind) {
         case Program::kVertex_Kind:
             this->internalConvertProgram(SKSL_VERT_INCLUDE, &ignored, &elements);
             break;
         case Program::kFragment_Kind:
             this->internalConvertProgram(SKSL_FRAG_INCLUDE, &ignored, &elements);
             break;
     }
+    fIRGenerator->fSymbolTable->markAllFunctionsBuiltin();
     Modifiers::Flag defaultPrecision;
     this->internalConvertProgram(text, &defaultPrecision, &elements);
     auto result = std::unique_ptr<Program>(new Program(kind, defaultPrecision, std::move(elements), 
-                                                       fIRGenerator->fSymbolTable));;
+                                                       fIRGenerator->fSymbolTable));
     fIRGenerator->popSymbolTable();
     this->writeErrorCount();
     return result;
 }
 
 void Compiler::error(Position position, std::string msg) {
     fErrorCount++;
     fErrorText += "error: " + position.description() + ": " + msg.c_str() + "\n";
 }
 
@@ skipping 46 matching lines @@
                       std::string* out) {
     std::stringstream buffer;
     bool result = this->toGLSL(kind, text, caps, buffer);
     if (result) {
         *out = buffer.str();
     }
     return result;
 }
 
 } // namespace