Line data    Source code

       1             : // Copyright 2018 the V8 project authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file.
       4             : 
       5             : #include <fstream>
       6             : #include <iostream>
       7             : 
       8             : #include "src/torque/declarable.h"
       9             : #include "src/torque/global-context.h"
      10             : 
      11             : namespace v8 {
      12             : namespace internal {
      13             : namespace torque {
      14             : 
      15      132908 : DEFINE_CONTEXTUAL_VARIABLE(CurrentScope)
      16             : 
      17           0 : std::ostream& operator<<(std::ostream& os, const QualifiedName& name) {
      18           0 :   for (const std::string& qualifier : name.namespace_qualification) {
      19           0 :     os << qualifier << "::";
      20             :   }
      21           0 :   return os << name.name;
      22             : }
      23             : 
      24           0 : std::ostream& operator<<(std::ostream& os, const Callable& m) {
      25           0 :   os << "callable " << m.ReadableName() << "(";
      26           0 :   if (m.signature().implicit_count != 0) {
      27           0 :     os << "implicit ";
      28             :     TypeVector implicit_parameter_types(
      29             :         m.signature().parameter_types.types.begin(),
      30             :         m.signature().parameter_types.types.begin() +
      31           0 :             m.signature().implicit_count);
      32           0 :     os << implicit_parameter_types << ")(";
      33             :     TypeVector explicit_parameter_types(
      34             :         m.signature().parameter_types.types.begin() +
      35           0 :             m.signature().implicit_count,
      36           0 :         m.signature().parameter_types.types.end());
      37           0 :     os << explicit_parameter_types;
      38             :   } else {
      39           0 :     os << m.signature().parameter_types;
      40             :   }
      41           0 :   os << "): " << *m.signature().return_type;
      42           0 :   return os;
      43             : }
      44             : 
      45           0 : std::ostream& operator<<(std::ostream& os, const Builtin& b) {
      46           0 :   os << "builtin " << *b.signature().return_type << " " << b.ReadableName()
      47           0 :      << b.signature().parameter_types;
      48           0 :   return os;
      49             : }
      50             : 
      51           0 : std::ostream& operator<<(std::ostream& os, const RuntimeFunction& b) {
      52           0 :   os << "runtime function " << *b.signature().return_type << " "
      53           0 :      << b.ReadableName() << b.signature().parameter_types;
      54           0 :   return os;
      55             : }
      56             : 
      57           0 : std::ostream& operator<<(std::ostream& os, const Generic& g) {
      58           0 :   os << "generic " << g.name() << "<";
      59           0 :   PrintCommaSeparatedList(
      60             :       os, g.declaration()->generic_parameters,
      61           0 :       [](const Identifier* identifier) { return identifier->value; });
      62           0 :   os << ">";
      63             : 
      64           0 :   return os;
      65             : }
      66             : 
      67             : namespace {
      68         564 : base::Optional<const Type*> InferTypeArgument(const std::string& to_infer,
      69             :                                               TypeExpression* parameter,
      70             :                                               const Type* argument) {
      71             :   BasicTypeExpression* basic = BasicTypeExpression::DynamicCast(parameter);
      72        1126 :   if (basic && basic->namespace_qualification.empty() && !basic->is_constexpr &&
      73         562 :       basic->name == to_infer) {
      74         498 :     return argument;
      75             :   }
      76             :   auto* ref = ReferenceTypeExpression::DynamicCast(parameter);
      77          66 :   if (ref && argument->IsReferenceType()) {
      78             :     return InferTypeArgument(to_infer, ref->referenced_type,
      79           2 :                              ReferenceType::cast(argument)->referenced_type());
      80             :   }
      81          64 :   return base::nullopt;
      82             : }
      83             : 
      84         498 : base::Optional<const Type*> InferTypeArgument(
      85             :     const std::string& to_infer, const std::vector<TypeExpression*>& parameters,
      86             :     const TypeVector& arguments) {
      87        1188 :   for (size_t i = 0; i < arguments.size() && i < parameters.size(); ++i) {
      88         562 :     if (base::Optional<const Type*> inferred =
      89        1124 :             InferTypeArgument(to_infer, parameters[i], arguments[i])) {
      90         498 :       return *inferred;
      91             :     }
      92             :   }
      93           0 :   return base::nullopt;
      94             : }
      95             : 
      96             : }  // namespace
      97             : 
      98        4976 : base::Optional<TypeVector> Generic::InferSpecializationTypes(
      99             :     const TypeVector& explicit_specialization_types,
     100             :     const TypeVector& arguments) {
     101        4976 :   TypeVector result = explicit_specialization_types;
     102             :   size_t type_parameter_count = declaration()->generic_parameters.size();
     103        4976 :   if (explicit_specialization_types.size() > type_parameter_count) {
     104             :     return base::nullopt;
     105             :   }
     106         498 :   for (size_t i = explicit_specialization_types.size();
     107        5474 :        i < type_parameter_count; ++i) {
     108         498 :     const std::string type_name = declaration()->generic_parameters[i]->value;
     109             :     size_t implicit_count =
     110         996 :         declaration()->callable->signature->parameters.implicit_count;
     111             :     const std::vector<TypeExpression*>& parameters =
     112             :         declaration()->callable->signature->parameters.types;
     113             :     std::vector<TypeExpression*> explicit_parameters(
     114         498 :         parameters.begin() + implicit_count, parameters.end());
     115             :     base::Optional<const Type*> inferred =
     116         498 :         InferTypeArgument(type_name, explicit_parameters, arguments);
     117         498 :     if (!inferred) return base::nullopt;
     118         498 :     result.push_back(*inferred);
     119             :   }
     120             :   return result;
     121             : }
     122             : 
     123       71294 : bool Namespace::IsDefaultNamespace() const {
     124       71294 :   return this == GlobalContext::GetDefaultNamespace();
     125             : }
     126             : 
     127         324 : bool Namespace::IsTestNamespace() const { return name() == kTestNamespaceName; }
     128             : 
     129             : }  // namespace torque
     130             : }  // namespace internal
     131       59456 : }  // namespace v8