chromium/v8/src/torque/declaration-visitor.cc

// Copyright 2017 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "src/torque/declaration-visitor.h"

#include <optional>

#include "src/torque/ast.h"
#include "src/torque/kythe-data.h"
#include "src/torque/server-data.h"
#include "src/torque/type-inference.h"
#include "src/torque/type-visitor.h"

namespace v8::internal::torque {

Namespace* GetOrCreateNamespace(const std::string& name) { … }

void PredeclarationVisitor::Predeclare(Declaration* decl) { … }

void DeclarationVisitor::Visit(Declaration* decl) { … }

Builtin* DeclarationVisitor::CreateBuiltin(BuiltinDeclaration* decl,
                                           std::string external_name,
                                           std::string readable_name,
                                           Signature signature,
                                           std::optional<Statement*> body) { … }

void DeclarationVisitor::Visit(ExternalBuiltinDeclaration* decl) { … }

void DeclarationVisitor::Visit(ExternalRuntimeDeclaration* decl) { … }

void DeclarationVisitor::Visit(ExternalMacroDeclaration* decl) { … }

void DeclarationVisitor::Visit(TorqueBuiltinDeclaration* decl) { … }

void DeclarationVisitor::Visit(TorqueMacroDeclaration* decl) { … }

void DeclarationVisitor::Visit(IntrinsicDeclaration* decl) { … }

void DeclarationVisitor::Visit(ConstDeclaration* decl) { … }

void DeclarationVisitor::Visit(SpecializationDeclaration* decl) { … }

void DeclarationVisitor::Visit(ExternConstDeclaration* decl) { … }

void DeclarationVisitor::Visit(CppIncludeDeclaration* decl) { … }

void DeclarationVisitor::DeclareSpecializedTypes(
    const SpecializationKey<GenericCallable>& key) { … }

Signature DeclarationVisitor::MakeSpecializedSignature(
    const SpecializationKey<GenericCallable>& key) { … }

Callable* DeclarationVisitor::SpecializeImplicit(
    const SpecializationKey<GenericCallable>& key) { … }

Callable* DeclarationVisitor::Specialize(
    const SpecializationKey<GenericCallable>& key,
    CallableDeclaration* declaration,
    std::optional<const SpecializationDeclaration*> explicit_specialization,
    std::optional<Statement*> body, SourcePosition position) { … }

void PredeclarationVisitor::ResolvePredeclarations() { … }

}  // namespace v8::internal::torque