chromium/v8/src/torque/declarable.cc

// Copyright 2018 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/declarable.h"

#include <fstream>
#include <iostream>
#include <optional>

#include "src/torque/ast.h"
#include "src/torque/global-context.h"
#include "src/torque/type-inference.h"
#include "src/torque/type-visitor.h"

namespace v8::internal::torque {

QualifiedName QualifiedName::Parse(std::string qualified_name) { … }

std::ostream& operator<<(std::ostream& os, const QualifiedName& name) { … }

std::ostream& operator<<(std::ostream& os, const Callable& m) { … }

std::ostream& operator<<(std::ostream& os, const Builtin& b) { … }

std::ostream& operator<<(std::ostream& os, const RuntimeFunction& b) { … }

std::ostream& operator<<(std::ostream& os, const GenericCallable& g) { … }

SpecializationRequester::SpecializationRequester(SourcePosition position,
                                                 Scope* s, std::string name)
    : … { … }

std::vector<Declarable*> Scope::Lookup(const QualifiedName& name) { … }

std::optional<std::string> TypeConstraint::IsViolated(const Type* type) const { … }

std::optional<std::string> FindConstraintViolation(
    const std::vector<const Type*>& types,
    const std::vector<TypeConstraint>& constraints) { … }

std::vector<TypeConstraint> ComputeConstraints(
    Scope* scope, const GenericParameters& parameters) { … }

TypeArgumentInference GenericCallable::InferSpecializationTypes(
    const TypeVector& explicit_specialization_types,
    const std::vector<std::optional<const Type*>>& arguments) { … }

std::optional<Statement*> GenericCallable::CallableBody() { … }

bool Namespace::IsDefaultNamespace() const { … }

bool Namespace::IsTestNamespace() const { … }

const Type* TypeAlias::Resolve() const { … }

}  // namespace v8::internal::torque