ScriptCompiler.h

浏览该文件的文档.

#pragma once
 
#include "common/BorrowedRef.h"
 
#include "common/Export.h"
 
#include <simplesquirrel/script.hpp>
 
#include <cstddef>
#include <cstdint>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
namespace ssq {
class VM;
}
 
namespace eve::script {
 
class ScriptModuleResolver;
 
enum class ScriptDiagnosticSeverity { Info, Warning, Error };
 
struct EVENGINE_API_FOUNDATION_INLINE ScriptSourcePosition {
    uint32_t line   = 1;
    uint32_t column = 1;
};
 
struct EVENGINE_API_FOUNDATION_INLINE ScriptDiagnostic {
    std::string              code;
    ScriptDiagnosticSeverity severity = ScriptDiagnosticSeverity::Error;
    std::string              message;
    std::string              canonicalUri;
    ScriptSourcePosition     position;
    std::string              related;
    std::string              fix;
};
 
struct EVENGINE_API_FOUNDATION_INLINE ScriptSourceMapEntry {
    ScriptSourcePosition generated;
    ScriptSourcePosition original;
};
 
struct EVENGINE_API_FOUNDATION ScriptSourceMap {
    std::string                       canonicalUri;
    std::vector<ScriptSourceMapEntry> entries;
 
    ScriptSourcePosition originalPosition(ScriptSourcePosition generated) const noexcept;
    ScriptSourcePosition generatedPosition(ScriptSourcePosition original) const noexcept;
};
 
struct EVENGINE_API_FOUNDATION_INLINE ScriptSymbolMetadata {
    std::string          name;
    std::string          kind;
    std::string          erasedType;
    ScriptSourcePosition position;
};
 
struct EVENGINE_API_FOUNDATION_INLINE ScriptPropertyMetadata {
    std::string                                  name;
    std::string                                  erasedType;
    ScriptSourcePosition                         position;
    std::unordered_map<std::string, std::string> attributes;
    std::vector<std::string>                     choices;
};
 
struct EVENGINE_API_FOUNDATION_INLINE ScriptMetadata {
    uint32_t                            languageVersion = 1;
    std::string                         sourceHash;
    std::string                         canonicalUri;
    std::string                         providerOrigin;
    std::vector<std::string>            imports;
    std::vector<std::string>            exports;
    std::vector<std::string>            dependencies;
    std::vector<std::string>            reverseDependencies;
    std::vector<ScriptSymbolMetadata>   symbols;
    std::vector<ScriptPropertyMetadata> properties;
    std::vector<std::string>            persistRoots;
    std::vector<std::string>            moduleReferences;
    std::vector<std::string>            asyncFunctions;
    std::vector<ScriptSourcePosition>   awaitLocations;
    ScriptSourceMap                     sourceMap;
    std::vector<ScriptDiagnostic>       diagnostics;
};
 
struct EVENGINE_API_FOUNDATION_INLINE ScriptCompletion {
    std::string label;
    std::string kind;
    std::string detail;
    std::string insertText;
};
 
struct EVENGINE_API_FOUNDATION_INLINE ScriptHover {
    std::string          symbol;
    std::string          markdown;
    ScriptSourcePosition position;
};
 
enum class ScriptUnit { None, Seconds, Milliseconds, Radians, Degrees, Pixels, Meters };
 
struct EVENGINE_API_FOUNDATION_INLINE BindingParameterContract {
    std::string                name;
    std::string                type     = "dynamic";
    bool                       nullable = false;
    std::optional<std::string> scriptDefault;
    ScriptUnit                 unit = ScriptUnit::None;
    std::vector<std::string>   choices;
};
 
struct EVENGINE_API_FOUNDATION BindingContract {
    std::string                           module;
    std::string                           scriptClass;
    std::string                           method;
    std::vector<BindingParameterContract> parameters;
    std::string                           returnType     = "dynamic";
    bool                                  returnNullable = false;
    std::string                           ownership;
    std::string                           threadAffinity = "main";
    std::vector<std::string>              platforms;
    std::string                           documentationId;
 
    std::string key() const;
    std::string toJson() const;
};
 
struct EVENGINE_API BindingSearchHit {
    BindingContract contract;
    int             score = 0;
};
 
class EVENGINE_API_FOUNDATION BindingContractRegistry {
public:
    void registerContract(BindingContract contract);
    bool unregisterContract(std::string_view key);
    const BindingContract* find(std::string_view key) const noexcept;
    const BindingContract* findMethod(std::string_view method) const noexcept;
    const BindingContract* findMethod(std::string_view scriptClass, std::string_view method) const noexcept;
    bool hasScriptClass(std::string_view scriptClass) const noexcept;
    std::vector<BindingContract> snapshot() const;
    std::vector<BindingSearchHit> search(std::string_view query, std::string_view moduleFilter = {},
                                         std::string_view classFilter = {}, size_t limit = 20) const;
 
private:
    struct Storage {
        std::unordered_map<std::string, BindingContract> contracts;
    };
 
    void                     ensureUnique();
    std::shared_ptr<Storage> storage_ = std::make_shared<Storage>();
};
 
class EVENGINE_API_FOUNDATION ScriptCompiler {
public:
    ScriptCompiler(ssq::VM& vm, ScriptModuleResolver& modules);
    ~ScriptCompiler();
 
    ssq::Script compileSource(std::string_view source, std::string_view sourceName);
    ssq::Script compileFile(std::string_view path);
    [[nodiscard]] eve::OptionalRef<const ScriptMetadata> metadata(std::string_view canonicalUri) const noexcept;
    std::vector<ScriptMetadata> metadataSnapshot() const;
    BindingContractRegistry& bindings() noexcept;
    const BindingContractRegistry& bindings() const noexcept;
    void registerAnnotation(std::string name);
    bool unregisterAnnotation(std::string_view name);
    std::vector<ScriptCompletion> completions(std::string_view canonicalUri, std::string_view prefix = {}) const;
    std::optional<ScriptHover> hover(std::string_view canonicalUri, std::string_view symbol) const;
    std::vector<ScriptDiagnostic> diagnostics(std::string_view canonicalUri) const;
    bool setSourceMap(std::string_view canonicalUri, ScriptSourceMap sourceMap);
    static ScriptSourcePosition toOriginalPosition(std::string_view source, ScriptSourcePosition generated);
    static ScriptSourcePosition toGeneratedPosition(std::string_view source, ScriptSourcePosition original);
    static SQRESULT compileBuffer(HSQUIRRELVM vm, const SQChar* source, SQInteger size, const SQChar* sourceName,
                                  SQBool raiseError);
    static std::vector<ScriptDiagnostic> validateProjectConfig(std::string_view source, std::string_view canonicalUri,
                                                               const std::vector<std::string>& knownModules,
                                                               const std::vector<std::string>& activeModules);
 
    static ScriptMetadata analyze(std::string_view source, std::string_view canonicalUri);
 
private:
    void                                            refreshDependencyMetadata();
    ssq::VM*                                        vm_;
    ScriptModuleResolver*                           modules_;
    BindingContractRegistry                         bindings_;
    std::unordered_set<std::string>                 nativeGlobals_;
    std::unordered_set<std::string>                 annotations_;
    std::unordered_map<std::string, ScriptMetadata> metadata_;
};
 
}  // namespace eve::script