SkSL performance improvements

src/sksl/ir/SkSLSymbolTable.h

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
  
 #ifndef SKSL_SYMBOLTABLE
 #define SKSL_SYMBOLTABLE
 
 #include <memory>
 #include <unordered_map>
 #include "SkSLErrorReporter.h"
 #include "SkSLSymbol.h"
 #include "SkSLUnresolvedFunction.h"
 
 namespace SkSL {
 
 /**
  * Maps identifiers to symbols. Functions, in particular, are mapped to either FunctionDeclaration
  * or UnresolvedFunction depending on whether they are overloaded or not.
  */
 class SymbolTable {
 public:
     SymbolTable(ErrorReporter& errorReporter)
-    : fErrorReporter(errorReporter) {}
-
-    SymbolTable(std::shared_ptr<SymbolTable> parent, ErrorReporter& errorReporter)
-    : fParent(parent)
+    : fOwner(true)

[dogben, 2016/07/08 19:56:40]

Would it be simpler for Block and FunctionDeclaration to own the SymbolTable
that owns their symbols? This would eliminate the need for fOwner. (We would
still need addWithoutOwnership for the global symbols and to add function
parameters to the function body block.)

     , fErrorReporter(errorReporter) {}
 
-    std::shared_ptr<Symbol> operator[](const std::string& name);
+    SymbolTable(std::shared_ptr<SymbolTable> parent, ErrorReporter& errorReporter, 
+                bool owner = false)
+    : fParent(parent)
+    , fOwner(owner)
+    , fErrorReporter(errorReporter) {}
 
-    void add(const std::string& name, std::shared_ptr<Symbol> symbol);
+    ~SymbolTable();
+
+    const Symbol* operator[](const std::string& name);
+
+    // SymbolTable will take ownership of the pointer, deleting it when it is destroyed
+    void add(const std::string& name, Symbol* symbol);

[dogben, 2016/07/08 19:56:40]

nit: use std::unique_ptr to transfer ownership

+
+    void addWithoutOwnership(const std::string& name, const Symbol* symbol);
+
+    void takeOwnership(Symbol* s);
 
     const std::shared_ptr<SymbolTable> fParent;
 
 private:
-    static std::vector<std::shared_ptr<FunctionDeclaration>> GetFunctions(
-                                                                  const std::shared_ptr<Symbol>& s);
+    static std::vector<const FunctionDeclaration*> GetFunctions(const Symbol& s);
 
-    std::unordered_map<std::string, std::shared_ptr<Symbol>> fSymbols;
+    // true if this symbol should directly own the pointers it contains, false to delegate ownership
+    // to its parent
+    const bool fOwner;
+
+    std::vector<Symbol*> fOwnedPointers;

[dogben, 2016/07/08 19:56:40]

nit: std::vector<std::unique_ptr<Symbol>> eliminates the destructor

+
+    std::unordered_map<std::string, const Symbol*> fSymbols;
 
     ErrorReporter& fErrorReporter;
 };
 
 } // namespace
 
 #endif