/*
 * 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_IRNODE
#define SKSL_IRNODE

#include "include/private/SkTArray.h"
#include "src/sksl/SkSLASTNode.h"
#include "src/sksl/SkSLLexer.h"
#include "src/sksl/SkSLModifiersPool.h"
#include "src/sksl/SkSLPool.h"
#include "src/sksl/SkSLString.h"

#include <algorithm>
#include <atomic>
#include <unordered_set>
#include <vector>

namespace SkSL {

class Expression;
class ExternalValue;
class FunctionDeclaration;
struct FunctionDefinition;
class Statement;
class Symbol;
class SymbolTable;
class Type;
class Variable;
class VariableReference;
enum class FieldAccessOwnerKind : int8_t;
enum class VariableRefKind : int8_t;
enum class VariableStorage : int8_t;

using ExpressionArray = SkSTArray<2, std::unique_ptr<Expression>>;
using StatementArray = SkSTArray<2, std::unique_ptr<Statement>>;

/**
 * Represents a node in the intermediate representation (IR) tree. The IR is a fully-resolved
 * version of the program (all types determined, everything validated), ready for code generation.
 */
class IRNode {
public:
    virtual ~IRNode();

    IRNode& operator=(const IRNode& other) {
        // Need to have a copy assignment operator because Type requires it, but can't use the
        // default version until we finish migrating away from std::unique_ptr children. For now,
        // just assert that there are no children (we could theoretically clone them, but we never
        // actually copy nodes containing children).
        SkASSERT(other.fExpressionChildren.empty());
        fKind = other.fKind;
        fOffset = other.fOffset;
        fData = other.fData;
        return *this;
    }

    virtual String description() const = 0;

    // character offset of this element within the program being compiled, for error reporting
    // purposes
    int fOffset;

    // Override operator new and delete to allow us to control allocation behavior.
    static void* operator new(const size_t size) {
        // TODO: once all IRNodes hold their data in fData, everything should come out of the pool,
        // and this check should become an assertion.
        if (size == sizeof(IRNode)) {
            return Pool::AllocIRNode();
        }
        return ::operator new(size);
    }

    static void operator delete(void* ptr) {
        Pool::FreeIRNode(ptr);
    }

protected:
    struct BlockData {
        std::shared_ptr<SymbolTable> fSymbolTable;
        // if isScope is false, this is just a group of statements rather than an actual
        // language-level block. This allows us to pass around multiple statements as if they were a
        // single unit, with no semantic impact.
        bool fIsScope;
    };

    struct BoolLiteralData {
        const Type* fType;
        bool fValue;
    };

    struct EnumData {
        StringFragment fTypeName;
        std::shared_ptr<SymbolTable> fSymbols;
        bool fIsSharedWithCpp;
        bool fIsBuiltin;
    };

    struct ExternalValueData {
        const Type* fType;
        const ExternalValue* fValue;
    };

    struct FieldData {
        StringFragment fName;
        const Type* fType;
        const Variable* fOwner;
        int fFieldIndex;
    };

    struct FieldAccessData {
        const Type* fType;
        int fFieldIndex;
        FieldAccessOwnerKind fOwnerKind;
    };

    struct FloatLiteralData {
        const Type* fType;
        float fValue;
    };

    struct ForStatementData {
        std::shared_ptr<SymbolTable> fSymbolTable;
    };

    struct FunctionCallData {
        const Type* fType;
        const FunctionDeclaration* fFunction;
    };

    struct FunctionDeclarationData {
        StringFragment fName;
        mutable const FunctionDefinition* fDefinition;
        ModifiersPool::Handle fModifiersHandle;
        // FIXME after killing fExpressionChildren / fStatementChildren in favor of just fChildren,
        // the parameters should move into that vector
        std::vector<const Variable*> fParameters;
        const Type* fReturnType;
        bool fBuiltin;

        FunctionDeclarationData& operator=(const FunctionDeclarationData& other) {
            fName = other.fName;
            fDefinition = other.fDefinition;
            fModifiersHandle = other.fModifiersHandle;
            fParameters = other.fParameters;
            fReturnType = other.fReturnType;
            fBuiltin = other.fBuiltin;
            return *this;
        }
    };

    struct FunctionDefinitionData {
        const FunctionDeclaration* fDeclaration;
        bool fBuiltin;
        // We track intrinsic functions we reference so that we can ensure that all of them end up
        // copied into the final output.
        std::unordered_set<const FunctionDeclaration*> fReferencedIntrinsics;
        // This pointer may be null, and even when non-null is not guaranteed to remain valid for
        // the entire lifespan of this object. The parse tree's lifespan is normally controlled by
        // IRGenerator, so the IRGenerator being destroyed or being used to compile another file
        // will invalidate this pointer.
        const ASTNode* fSource;
    };

    struct FunctionReferenceData {
        const Type* fType;
        std::vector<const FunctionDeclaration*> fFunctions;
     };

    struct IfStatementData {
        bool fIsStatic;
    };

    struct InterfaceBlockData {
        const Variable* fVariable;
        String fTypeName;
        String fInstanceName;
        std::shared_ptr<SymbolTable> fTypeOwner;
    };

    struct IntLiteralData {
        const Type* fType;
        int64_t fValue;
    };

    struct InlineMarkerData {
        const FunctionDeclaration* fFunction;
    };

    struct ModifiersDeclarationData {
        ModifiersPool::Handle fModifiersHandle;
    };

    struct SectionData {
        String fName;
        String fArgument;
        String fText;
    };

    struct SettingData {
        String fName;
        const Type* fType;
    };

    struct SwizzleData {
        const Type* fType;
        std::vector<int> fComponents;
    };

    struct SymbolData {
        StringFragment fName;
        const Type* fType;
    };

    struct SymbolAliasData {
        StringFragment fName;
        const Symbol* fOrigSymbol;
    };

    struct TypeReferenceData {
        const Type* fType;
        const Type* fValue;
     };

    struct TypeTokenData {
        const Type* fType;
        Token::Kind fToken;
    };

    struct UnresolvedFunctionData {
        // FIXME move this into the child vector after killing fExpressionChildren /
        // fStatementChildren
        std::vector<const FunctionDeclaration*> fFunctions;
    };

    struct VarDeclarationData {
        const Type* fBaseType;
        const Variable* fVar;
    };

    struct VariableData {
        StringFragment fName;
        const Type* fType;
        const Expression* fInitialValue = nullptr;
        ModifiersPool::Handle fModifiersHandle;
        // Tracks how many sites read from the variable. If this is zero for a non-out variable (or
        // becomes zero during optimization), the variable is dead and may be eliminated.
        mutable int16_t fReadCount;
        // Tracks how many sites write to the variable. If this is zero, the variable is dead and
        // may be eliminated.
        mutable int16_t fWriteCount;
        VariableStorage fStorage;
        bool fBuiltin;
    };

    struct VariableReferenceData {
        const Variable* fVariable;
        VariableRefKind fRefKind;
    };

    struct NodeData {
        enum class Kind {
            kBlock,
            kBoolLiteral,
            kEnum,
            kExternalValue,
            kField,
            kFieldAccess,
            kFloatLiteral,
            kForStatement,
            kFunctionCall,
            kFunctionDeclaration,
            kFunctionDefinition,
            kFunctionReference,
            kIfStatement,
            kInlineMarker,
            kInterfaceBlock,
            kIntLiteral,
            kModifiersDeclaration,
            kSection,
            kSetting,
            kString,
            kSwizzle,
            kSymbol,
            kSymbolAlias,
            kType,
            kTypeReference,
            kTypeToken,
            kUnresolvedFunction,
            kVarDeclaration,
            kVariable,
            kVariableReference,
        } fKind = Kind::kType;
        // it doesn't really matter what kind we default to, as long as it's a POD type

        union Contents {
            BlockData fBlock;
            BoolLiteralData fBoolLiteral;
            EnumData fEnum;
            ExternalValueData fExternalValue;
            FieldData fField;
            FieldAccessData fFieldAccess;
            FloatLiteralData fFloatLiteral;
            ForStatementData fForStatement;
            FunctionCallData fFunctionCall;
            FunctionDeclarationData fFunctionDeclaration;
            FunctionDefinitionData fFunctionDefinition;
            FunctionReferenceData fFunctionReference;
            IfStatementData fIfStatement;
            InlineMarkerData fInlineMarker;
            InterfaceBlockData fInterfaceBlock;
            IntLiteralData fIntLiteral;
            ModifiersDeclarationData fModifiersDeclaration;
            SectionData fSection;
            SettingData fSetting;
            String fString;
            SwizzleData fSwizzle;
            SymbolData fSymbol;
            SymbolAliasData fSymbolAlias;
            const Type* fType;
            TypeReferenceData fTypeReference;
            TypeTokenData fTypeToken;
            UnresolvedFunctionData fUnresolvedFunction;
            VarDeclarationData fVarDeclaration;
            VariableData fVariable;
            VariableReferenceData fVariableReference;

            Contents() {}

            ~Contents() {}
        } fContents;

        NodeData(const BlockData& data)
            : fKind(Kind::kBlock) {
            *(new(&fContents) BlockData) = data;
        }

        NodeData(const BoolLiteralData& data)
            : fKind(Kind::kBoolLiteral) {
            *(new(&fContents) BoolLiteralData) = data;
        }

        NodeData(const EnumData& data)
            : fKind(Kind::kEnum) {
            *(new(&fContents) EnumData) = data;
        }

        NodeData(const ExternalValueData& data)
            : fKind(Kind::kExternalValue) {
            *(new(&fContents) ExternalValueData) = data;
        }

        NodeData(const FieldData& data)
            : fKind(Kind::kField) {
            *(new(&fContents) FieldData) = data;
        }

        NodeData(const FieldAccessData& data)
            : fKind(Kind::kFieldAccess) {
            *(new(&fContents) FieldAccessData) = data;
        }

        NodeData(const FloatLiteralData& data)
            : fKind(Kind::kFloatLiteral) {
            *(new(&fContents) FloatLiteralData) = data;
        }

        NodeData(const ForStatementData& data)
            : fKind(Kind::kForStatement) {
            *(new(&fContents) ForStatementData) = data;
        }

        NodeData(const FunctionCallData& data)
            : fKind(Kind::kFunctionCall) {
            *(new(&fContents) FunctionCallData) = data;
        }

        NodeData(const FunctionDeclarationData& data)
            : fKind(Kind::kFunctionDeclaration) {
            *(new(&fContents) FunctionDeclarationData) = data;
        }

        NodeData(const FunctionDefinitionData& data)
            : fKind(Kind::kFunctionDefinition) {
            *(new(&fContents) FunctionDefinitionData) = data;
        }

        NodeData(const FunctionReferenceData& data)
            : fKind(Kind::kFunctionReference) {
            *(new(&fContents) FunctionReferenceData) = data;
        }

        NodeData(IfStatementData data)
            : fKind(Kind::kIfStatement) {
            *(new(&fContents) IfStatementData) = data;
        }

        NodeData(InlineMarkerData data)
            : fKind(Kind::kInlineMarker) {
            *(new(&fContents) InlineMarkerData) = data;
        }

        NodeData(InterfaceBlockData data)
            : fKind(Kind::kInterfaceBlock) {
            *(new(&fContents) InterfaceBlockData) = data;
        }

        NodeData(IntLiteralData data)
            : fKind(Kind::kIntLiteral) {
            *(new(&fContents) IntLiteralData) = data;
        }

        NodeData(ModifiersDeclarationData data)
            : fKind(Kind::kModifiersDeclaration) {
            *(new(&fContents) ModifiersDeclarationData) = data;
        }

        NodeData(const SectionData& data)
            : fKind(Kind::kSection) {
            *(new(&fContents) SectionData) = data;
        }

        NodeData(const SettingData& data)
            : fKind(Kind::kSetting) {
            *(new(&fContents) SettingData) = data;
        }

        NodeData(const String& data)
            : fKind(Kind::kString) {
            *(new(&fContents) String) = data;
        }

        NodeData(const SwizzleData& data)
            : fKind(Kind::kSwizzle) {
            *(new(&fContents) SwizzleData) = data;
        }

        NodeData(const SymbolData& data)
            : fKind(Kind::kSymbol) {
            *(new(&fContents) SymbolData) = data;
        }

        NodeData(const SymbolAliasData& data)
            : fKind(Kind::kSymbolAlias) {
            *(new(&fContents) SymbolAliasData) = data;
        }

        NodeData(const Type* data)
            : fKind(Kind::kType) {
            *(new(&fContents) const Type*) = data;
        }

        NodeData(const TypeReferenceData& data)
            : fKind(Kind::kTypeReference) {
            *(new(&fContents) TypeReferenceData) = data;
        }

        NodeData(const TypeTokenData& data)
            : fKind(Kind::kTypeToken) {
            *(new(&fContents) TypeTokenData) = data;
        }

        NodeData(const UnresolvedFunctionData& data)
            : fKind(Kind::kUnresolvedFunction) {
            *(new(&fContents) UnresolvedFunctionData) = data;
        }

        NodeData(const VarDeclarationData& data)
            : fKind(Kind::kVarDeclaration) {
            *(new(&fContents) VarDeclarationData) = data;
        }

        NodeData(const VariableData& data)
            : fKind(Kind::kVariable) {
            *(new(&fContents) VariableData) = data;
        }

        NodeData(const VariableReferenceData& data)
            : fKind(Kind::kVariableReference) {
            *(new(&fContents) VariableReferenceData) = data;
        }

        NodeData(const NodeData& other) {
            *this = other;
        }

        NodeData& operator=(const NodeData& other) {
            this->cleanup();
            fKind = other.fKind;
            switch (fKind) {
                case Kind::kBlock:
                    *(new(&fContents) BlockData) = other.fContents.fBlock;
                    break;
                case Kind::kBoolLiteral:
                    *(new(&fContents) BoolLiteralData) = other.fContents.fBoolLiteral;
                    break;
                case Kind::kEnum:
                    *(new(&fContents) EnumData) = other.fContents.fEnum;
                    break;
                case Kind::kExternalValue:
                    *(new(&fContents) ExternalValueData) = other.fContents.fExternalValue;
                    break;
                case Kind::kField:
                    *(new(&fContents) FieldData) = other.fContents.fField;
                    break;
                case Kind::kFieldAccess:
                    *(new(&fContents) FieldAccessData) = other.fContents.fFieldAccess;
                    break;
                case Kind::kFloatLiteral:
                    *(new(&fContents) FloatLiteralData) = other.fContents.fFloatLiteral;
                    break;
                case Kind::kForStatement:
                    *(new(&fContents) ForStatementData) = other.fContents.fForStatement;
                    break;
                case Kind::kFunctionCall:
                    *(new(&fContents) FunctionCallData) = other.fContents.fFunctionCall;
                    break;
                case Kind::kFunctionDeclaration:
                    *(new(&fContents) FunctionDeclarationData) =
                                                               other.fContents.fFunctionDeclaration;
                    break;
                case Kind::kFunctionDefinition:
                    *(new(&fContents) FunctionDefinitionData) = other.fContents.fFunctionDefinition;
                    break;
                case Kind::kFunctionReference:
                    *(new(&fContents) FunctionReferenceData) = other.fContents.fFunctionReference;
                    break;
                case Kind::kIfStatement:
                    *(new(&fContents) IfStatementData) = other.fContents.fIfStatement;
                    break;
                case Kind::kInlineMarker:
                    *(new(&fContents) InlineMarkerData) = other.fContents.fInlineMarker;
                    break;
                case Kind::kInterfaceBlock:
                    *(new(&fContents) InterfaceBlockData) = other.fContents.fInterfaceBlock;
                    break;
                case Kind::kIntLiteral:
                    *(new(&fContents) IntLiteralData) = other.fContents.fIntLiteral;
                    break;
                case Kind::kModifiersDeclaration:
                    *(new(&fContents) ModifiersDeclarationData) =
                                                              other.fContents.fModifiersDeclaration;
                    break;
                case Kind::kSection:
                    *(new(&fContents) SectionData) = other.fContents.fSection;
                    break;
                case Kind::kSetting:
                    *(new(&fContents) SettingData) = other.fContents.fSetting;
                    break;
                case Kind::kString:
                    *(new(&fContents) String) = other.fContents.fString;
                    break;
                case Kind::kSwizzle:
                    *(new(&fContents) SwizzleData) = other.fContents.fSwizzle;
                    break;
                case Kind::kSymbol:
                    *(new(&fContents) SymbolData) = other.fContents.fSymbol;
                    break;
                case Kind::kSymbolAlias:
                    *(new(&fContents) SymbolAliasData) = other.fContents.fSymbolAlias;
                    break;
                case Kind::kType:
                    *(new(&fContents) const Type*) = other.fContents.fType;
                    break;
                case Kind::kTypeReference:
                    *(new(&fContents) TypeReferenceData) = other.fContents.fTypeReference;
                    break;
                case Kind::kTypeToken:
                    *(new(&fContents) TypeTokenData) = other.fContents.fTypeToken;
                    break;
                case Kind::kUnresolvedFunction:
                    *(new(&fContents) UnresolvedFunctionData) = other.fContents.fUnresolvedFunction;
                    break;
                case Kind::kVarDeclaration:
                    *(new(&fContents) VarDeclarationData) = other.fContents.fVarDeclaration;
                    break;
                case Kind::kVariable:
                    *(new(&fContents) VariableData) = other.fContents.fVariable;
                    break;
                case Kind::kVariableReference:
                    *(new(&fContents) VariableReferenceData) = other.fContents.fVariableReference;
                    break;
            }
            return *this;
        }

        ~NodeData() {
            this->cleanup();
        }

    private:
        void cleanup() {
            switch (fKind) {
                case Kind::kBlock:
                    fContents.fBlock.~BlockData();
                    break;
                case Kind::kBoolLiteral:
                    fContents.fBoolLiteral.~BoolLiteralData();
                    break;
                case Kind::kEnum:
                    fContents.fEnum.~EnumData();
                    break;
                case Kind::kExternalValue:
                    fContents.fExternalValue.~ExternalValueData();
                    break;
                case Kind::kField:
                    fContents.fField.~FieldData();
                    break;
                case Kind::kFieldAccess:
                    fContents.fFieldAccess.~FieldAccessData();
                    break;
                case Kind::kFloatLiteral:
                    fContents.fFloatLiteral.~FloatLiteralData();
                    break;
                case Kind::kForStatement:
                    fContents.fForStatement.~ForStatementData();
                    break;
                case Kind::kFunctionCall:
                    fContents.fFunctionCall.~FunctionCallData();
                    break;
                case Kind::kFunctionDeclaration:
                    fContents.fFunctionDeclaration.~FunctionDeclarationData();
                    break;
                case Kind::kFunctionDefinition:
                    fContents.fFunctionDefinition.~FunctionDefinitionData();
                    break;
                case Kind::kFunctionReference:
                    fContents.fFunctionReference.~FunctionReferenceData();
                    break;
                case Kind::kIfStatement:
                    fContents.fIfStatement.~IfStatementData();
                    break;
                case Kind::kInlineMarker:
                    fContents.fInlineMarker.~InlineMarkerData();
                    break;
                case Kind::kInterfaceBlock:
                    fContents.fInterfaceBlock.~InterfaceBlockData();
                    break;
                case Kind::kIntLiteral:
                    fContents.fIntLiteral.~IntLiteralData();
                    break;
                case Kind::kModifiersDeclaration:
                    fContents.fModifiersDeclaration.~ModifiersDeclarationData();
                    break;
                case Kind::kSection:
                    fContents.fSection.~SectionData();
                    break;
                case Kind::kSetting:
                    fContents.fSetting.~SettingData();
                    break;
                case Kind::kString:
                    fContents.fString.~String();
                    break;
                case Kind::kSwizzle:
                    fContents.fSwizzle.~SwizzleData();
                    break;
                case Kind::kSymbol:
                    fContents.fSymbol.~SymbolData();
                    break;
                case Kind::kSymbolAlias:
                    fContents.fSymbolAlias.~SymbolAliasData();
                    break;
                case Kind::kType:
                    break;
                case Kind::kTypeReference:
                    fContents.fTypeReference.~TypeReferenceData();
                    break;
                case Kind::kTypeToken:
                    fContents.fTypeToken.~TypeTokenData();
                    break;
                case Kind::kUnresolvedFunction:
                    fContents.fUnresolvedFunction.~UnresolvedFunctionData();
                    break;
                case Kind::kVarDeclaration:
                    fContents.fVarDeclaration.~VarDeclarationData();
                    break;
                case Kind::kVariable:
                    fContents.fVariable.~VariableData();
                    break;
                case Kind::kVariableReference:
                    fContents.fVariableReference.~VariableReferenceData();
                    break;
            }
        }
    };

    IRNode(int offset, int kind, const BlockData& data, StatementArray stmts);

    IRNode(int offset, int kind, const BoolLiteralData& data);

    IRNode(int offset, int kind, const EnumData& data);

    IRNode(int offset, int kind, const ExternalValueData& data);

    IRNode(int offset, int kind, const FieldData& data);

    IRNode(int offset, int kind, const FieldAccessData& data);

    IRNode(int offset, int kind, const FloatLiteralData& data);

    IRNode(int offset, int kind, const ForStatementData& data);

    IRNode(int offset, int kind, const FunctionCallData& data);

    IRNode(int offset, int kind, const FunctionDeclarationData& data);

    IRNode(int offset, int kind, const FunctionDefinitionData& data);

    IRNode(int offset, int kind, const FunctionReferenceData& data);

    IRNode(int offset, int kind, const IfStatementData& data);

    IRNode(int offset, int kind, const InlineMarkerData& data);

    IRNode(int offset, int kind, const InterfaceBlockData& data);

    IRNode(int offset, int kind, const IntLiteralData& data);

    IRNode(int offset, int kind, const ModifiersDeclarationData& data);

    IRNode(int offset, int kind, const SectionData& data);

    IRNode(int offset, int kind, const SettingData& data);

    IRNode(int offset, int kind, const String& data);

    IRNode(int offset, int kind, const SwizzleData& data);

    IRNode(int offset, int kind, const SymbolData& data);

    IRNode(int offset, int kind, const SymbolAliasData& data);

    IRNode(int offset, int kind, const Type* data = nullptr);

    IRNode(int offset, int kind, const TypeReferenceData& data);

    IRNode(int offset, int kind, const TypeTokenData& data);

    IRNode(int offset, int kind, const UnresolvedFunctionData& data);

    IRNode(int offset, int kind, const VarDeclarationData& data);

    IRNode(int offset, int kind, const VariableData& data);

    IRNode(int offset, int kind, const VariableReferenceData& data);

    Expression& expressionChild(int index) const {
        SkASSERT(index >= 0 && index < (int) fExpressionChildren.size());
        return *fExpressionChildren[index];
    }

    std::unique_ptr<Expression>& expressionPointer(int index) {
        SkASSERT(index >= 0 && index < (int) fExpressionChildren.size());
        return fExpressionChildren[index];
    }

    const std::unique_ptr<Expression>& expressionPointer(int index) const {
        SkASSERT(index >= 0 && index < (int) fExpressionChildren.size());
        return fExpressionChildren[index];
    }

    int expressionChildCount() const {
        return fExpressionChildren.size();
    }


    Statement& statementChild(int index) const {
        SkASSERT(index >= 0 && index < (int) fStatementChildren.size());
        return *fStatementChildren[index];
    }

    std::unique_ptr<Statement>& statementPointer(int index) {
        SkASSERT(index >= 0 && index < (int) fStatementChildren.size());
        return fStatementChildren[index];
    }

    const std::unique_ptr<Statement>& statementPointer(int index) const {
        SkASSERT(index >= 0 && index < (int) fStatementChildren.size());
        return fStatementChildren[index];
    }

    int statementChildCount() const {
        return fStatementChildren.size();
    }

    BlockData& blockData() {
        SkASSERT(fData.fKind == NodeData::Kind::kBlock);
        return fData.fContents.fBlock;
    }

    const BlockData& blockData() const {
        SkASSERT(fData.fKind == NodeData::Kind::kBlock);
        return fData.fContents.fBlock;
    }

    const BoolLiteralData& boolLiteralData() const {
        SkASSERT(fData.fKind == NodeData::Kind::kBoolLiteral);
        return fData.fContents.fBoolLiteral;
    }

    const EnumData& enumData() const {
        SkASSERT(fData.fKind == NodeData::Kind::kEnum);
        return fData.fContents.fEnum;
    }

    const ExternalValueData& externalValueData() const {
        SkASSERT(fData.fKind == NodeData::Kind::kExternalValue);
        return fData.fContents.fExternalValue;
    }

    const FieldData& fieldData() const {
        SkASSERT(fData.fKind == NodeData::Kind::kField);
        return fData.fContents.fField;
    }

    const FieldAccessData& fieldAccessData() const {
        SkASSERT(fData.fKind == NodeData::Kind::kFieldAccess);
        return fData.fContents.fFieldAccess;
    }

    const FloatLiteralData& floatLiteralData() const {
        SkASSERT(fData.fKind == NodeData::Kind::kFloatLiteral);
        return fData.fContents.fFloatLiteral;
    }

    const ForStatementData& forStatementData() const {
        SkASSERT(fData.fKind == NodeData::Kind::kForStatement);
        return fData.fContents.fForStatement;
    }

    const FunctionCallData& functionCallData() const {
        SkASSERT(fData.fKind == NodeData::Kind::kFunctionCall);
        return fData.fContents.fFunctionCall;
    }

    FunctionDeclarationData& functionDeclarationData() {
        SkASSERT(fData.fKind == NodeData::Kind::kFunctionDeclaration);
        return fData.fContents.fFunctionDeclaration;
    }

    const FunctionDeclarationData& functionDeclarationData() const {
        SkASSERT(fData.fKind == NodeData::Kind::kFunctionDeclaration);
        return fData.fContents.fFunctionDeclaration;
    }

    FunctionDefinitionData& functionDefinitionData() {
        SkASSERT(fData.fKind == NodeData::Kind::kFunctionDefinition);
        return fData.fContents.fFunctionDefinition;
    }

    const FunctionDefinitionData& functionDefinitionData() const {
        SkASSERT(fData.fKind == NodeData::Kind::kFunctionDefinition);
        return fData.fContents.fFunctionDefinition;
    }

    const FunctionReferenceData& functionReferenceData() const {
        SkASSERT(fData.fKind == NodeData::Kind::kFunctionReference);
        return fData.fContents.fFunctionReference;
    }

    const IfStatementData& ifStatementData() const {
        SkASSERT(fData.fKind == NodeData::Kind::kIfStatement);
        return fData.fContents.fIfStatement;
    }

    const InlineMarkerData& inlineMarkerData() const {
        SkASSERT(fData.fKind == NodeData::Kind::kInlineMarker);
        return fData.fContents.fInlineMarker;
    }

    InterfaceBlockData& interfaceBlockData() {
        SkASSERT(fData.fKind == NodeData::Kind::kInterfaceBlock);
        return fData.fContents.fInterfaceBlock;
    }

    const InterfaceBlockData& interfaceBlockData() const {
        SkASSERT(fData.fKind == NodeData::Kind::kInterfaceBlock);
        return fData.fContents.fInterfaceBlock;
    }

    const IntLiteralData& intLiteralData() const {
        SkASSERT(fData.fKind == NodeData::Kind::kIntLiteral);
        return fData.fContents.fIntLiteral;
    }

    const ModifiersDeclarationData& modifiersDeclarationData() const {
        SkASSERT(fData.fKind == NodeData::Kind::kModifiersDeclaration);
        return fData.fContents.fModifiersDeclaration;
    }

    const SectionData& sectionData() const {
        SkASSERT(fData.fKind == NodeData::Kind::kSection);
        return fData.fContents.fSection;
    }

    const SettingData& settingData() const {
        SkASSERT(fData.fKind == NodeData::Kind::kSetting);
        return fData.fContents.fSetting;
    }

    const String& stringData() const {
        SkASSERT(fData.fKind == NodeData::Kind::kString);
        return fData.fContents.fString;
    }

    SwizzleData& swizzleData() {
        SkASSERT(fData.fKind == NodeData::Kind::kSwizzle);
        return fData.fContents.fSwizzle;
    }

    const SwizzleData& swizzleData() const {
        SkASSERT(fData.fKind == NodeData::Kind::kSwizzle);
        return fData.fContents.fSwizzle;
    }

    SymbolData& symbolData() {
        SkASSERT(fData.fKind == NodeData::Kind::kSymbol);
        return fData.fContents.fSymbol;
    }

    const SymbolData& symbolData() const {
        SkASSERT(fData.fKind == NodeData::Kind::kSymbol);
        return fData.fContents.fSymbol;
    }

    const SymbolAliasData& symbolAliasData() const {
        SkASSERT(fData.fKind == NodeData::Kind::kSymbolAlias);
        return fData.fContents.fSymbolAlias;
    }

    const Type* typeData() const {
        SkASSERT(fData.fKind == NodeData::Kind::kType);
        return fData.fContents.fType;
    }

    const TypeReferenceData& typeReferenceData() const {
        SkASSERT(fData.fKind == NodeData::Kind::kTypeReference);
        return fData.fContents.fTypeReference;
    }

    const TypeTokenData& typeTokenData() const {
        SkASSERT(fData.fKind == NodeData::Kind::kTypeToken);
        return fData.fContents.fTypeToken;
    }

    const UnresolvedFunctionData& unresolvedFunctionData() const {
        SkASSERT(fData.fKind == NodeData::Kind::kUnresolvedFunction);
        return fData.fContents.fUnresolvedFunction;
    }

    VarDeclarationData& varDeclarationData() {
        SkASSERT(fData.fKind == NodeData::Kind::kVarDeclaration);
        return fData.fContents.fVarDeclaration;
    }

    const VarDeclarationData& varDeclarationData() const {
        SkASSERT(fData.fKind == NodeData::Kind::kVarDeclaration);
        return fData.fContents.fVarDeclaration;
    }

    VariableData& variableData() {
        SkASSERT(fData.fKind == NodeData::Kind::kVariable);
        return fData.fContents.fVariable;
    }

    const VariableData& variableData() const {
        SkASSERT(fData.fKind == NodeData::Kind::kVariable);
        return fData.fContents.fVariable;
    }

    VariableReferenceData& variableReferenceData() {
        SkASSERT(fData.fKind == NodeData::Kind::kVariableReference);
        return fData.fContents.fVariableReference;
    }

    const VariableReferenceData& variableReferenceData() const {
        SkASSERT(fData.fKind == NodeData::Kind::kVariableReference);
        return fData.fContents.fVariableReference;
    }

    int fKind;

    NodeData fData;

    // Needing two separate vectors is a temporary issue. Ideally, we'd just be able to use a single
    // vector of nodes, but there are various spots where we take pointers to std::unique_ptr<>,
    // and it isn't safe to pun std::unique_ptr<IRNode> to std::unique_ptr<Statement / Expression>.
    // And we can't update the call sites to expect std::unique_ptr<IRNode> while there are still
    // old-style nodes around.
    // When the transition is finished, we'll be able to drop the unique_ptrs and just handle
    // <IRNode> directly.
    ExpressionArray fExpressionChildren;
    // it's important to keep the statement array defined after (and thus destroyed before) fData,
    // because destroying statements can modify reference counts in a SymbolTable contained in fData
    StatementArray fStatementChildren;
};

}  // namespace SkSL

#endif