initial checkin of SkSL compiler

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 {
+
+std::vector<std::shared_ptr<FunctionDeclaration>> get_functions(std::shared_ptr<Symbol> s);

[dogben, 2016/06/21 21:52:50]

nit: make this a static method of SymbolTable?

+
+/**
+ * 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)
+    , fErrorReporter(errorReporter) {}
+
+    std::shared_ptr<Symbol> operator[](std::string name) {

[dogben, 2016/06/21 21:52:51]

Can this return const ref?

IIUC, every creation and destruction of std::shared_ptr is a memory barrier, so
it's really worth the trouble to eliminate as many copies as possible.

+        auto entry = fSymbols.find(name);

[dogben, 2016/06/21 21:52:50]

nit: const ref

+        if (entry == fSymbols.end()) {
+            if (fParent != nullptr) {
+                return (*fParent)[name];
+            }
+            return nullptr;
+        }
+        if (fParent != nullptr) {
+            auto functions = get_functions(entry->second);
+            if (functions.size() > 0) {
+                bool modified = false;
+                std::shared_ptr<Symbol> previous = (*fParent)[name];
+                auto previousFunctions = get_functions(entry->second);

[dogben, 2016/06/21 21:52:50]

Should this be get_functions(previous)?

+                for (std::shared_ptr<FunctionDeclaration> prev : previousFunctions) {

[dogben, 2016/06/21 21:52:50]

nit: const ref

Next loop also.

+                    bool found = false;
+                    for (std::shared_ptr<FunctionDeclaration> current : functions) {
+                        if (current->matches(prev)) {
+                            found = true;
+                            break;
+                        }
+                    }
+                    if (!found) {
+                        functions.push_back(prev);
+                        modified = true;
+                    }
+                }
+                if (modified) {
+                    ASSERT(functions.count() > 1);
+                    return std::shared_ptr<Symbol>(new UnresolvedFunction(functions));
+                }
+            }
+        }
+        return entry->second;
+    }
+
+    void add(std::string name, std::shared_ptr<Symbol> symbol) {
+        auto existing = fSymbols.find(name);
+        if (existing == fSymbols.end()) {
+            fSymbols[name] = symbol;

[dogben, 2016/06/21 21:52:51]

nit: std::move(symbol), everywhere in this function.

+        } else if (symbol->fKind == Symbol::kFunctionDeclaration_Kind) {
+            std::shared_ptr<Symbol> oldSymbol = existing->second;

[dogben, 2016/06/21 21:52:51]

nit: const ref?

Or regular ref and use .reset below?

+            if (oldSymbol->fKind == Symbol::kFunctionDeclaration_Kind) {
+                std::vector<std::shared_ptr<FunctionDeclaration>> functions;

[dogben, 2016/06/21 21:52:50]

nit: Construct with capacity 2?

Or use {} initialization?

+                functions.push_back(std::static_pointer_cast<FunctionDeclaration>(oldSymbol));
+                functions.push_back(std::static_pointer_cast<FunctionDeclaration>(symbol));
+                fSymbols[name] = std::shared_ptr<Symbol>(new UnresolvedFunction(functions));

[dogben, 2016/06/21 21:52:51]

nit: std::move, two places

+            } else if (oldSymbol->fKind == Symbol::kUnresolvedFunction_Kind) {
+                std::vector<std::shared_ptr<FunctionDeclaration>> functions;

[dogben, 2016/06/21 21:52:50]

nit: Construct with capacity
std::static_pointer_cast<UnresolvedFunction>(oldSymbol)->fFunctions.size()?

+                for (auto f : std::static_pointer_cast<UnresolvedFunction>(oldSymbol)->fFunctions) {

[dogben, 2016/06/21 21:52:51]

nit: const auto&

Or:
const auto& oldFunctions =
std::static_pointer_cast<UnresolvedFunction>(oldSymbol)->fFunctions;
functions.insert(functions.end(), oldFunctions.begin(), oldFunctions.end());

+                    functions.push_back(f);
+                }
+                functions.push_back(std::static_pointer_cast<FunctionDeclaration>(symbol));
+                fSymbols[name] = std::shared_ptr<Symbol>(new UnresolvedFunction(functions));
+            }

[dogben, 2016/06/21 21:52:50]

else error?

+        } else {
+            fErrorReporter.error(symbol->fPosition, "symbol '" + name + "' was already defined");
+        }
+    }
+
+    const std::shared_ptr<SymbolTable> fParent;
+
+private:
+    std::unordered_map<std::string, std::shared_ptr<Symbol>> fSymbols;
+
+    ErrorReporter& fErrorReporter;
+};
+
+} // namespace
+
+#endif