gcc/rust/ast/rust-path.cc

   1 /* General AST-related method implementations for Rust frontend.
   2    Copyright (C) 2009-2024 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify it under
   7 the terms of the GNU General Public License as published by the Free
   8 Software Foundation; either version 3, or (at your option) any later
   9 version.
  10
  11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GCC; see the file COPYING3.  If not see
  18 <http://www.gnu.org/licenses/>.  */
  19
  20 #include "rust-system.h"
  21 #include "rust-ast-full.h"
  22 #include "rust-diagnostics.h"
  23 #include "rust-ast-visitor.h"
  24 #include "rust-macro.h"
  25 #include "rust-session-manager.h"
  26 #include "rust-lex.h"
  27 #include "rust-parse.h"
  28 #include "rust-operators.h"
  29
  30 namespace Rust {
  31 namespace AST {
  32
  33 std::string
  34 GenericArgs::as_string () const
  35 {
  36   std::string args;
  37
  38   // lifetime args
  39   if (!lifetime_args.empty ())
  40     {
  41       auto i = lifetime_args.begin ();
  42       auto e = lifetime_args.end ();
  43
  44       for (; i != e; i++)
  45         {
  46           args += (*i).as_string ();
  47           if (e != i + 1)
  48             args += ", ";
  49         }
  50     }
  51
  52   // type args
  53   if (!generic_args.empty ())
  54     {
  55       auto i = generic_args.begin ();
  56       auto e = generic_args.end ();
  57
  58       for (; i != e; i++)
  59         {
  60           args += (*i).as_string ();
  61           if (e != i + 1)
  62             args += ", ";
  63         }
  64     }
  65
  66   // binding args
  67   if (!binding_args.empty ())
  68     {
  69       auto i = binding_args.begin ();
  70       auto e = binding_args.end ();
  71
  72       for (; i != e; i++)
  73         {
  74           args += (*i).as_string ();
  75           if (e != i + 1)
  76             args += ", ";
  77         }
  78     }
  79
  80   return args;
  81 }
  82
  83 GenericArg
  84 GenericArg::disambiguate_to_const () const
  85 {
  86   rust_assert (get_kind () == Kind::Either);
  87
  88   // FIXME: is it fine to have no outer attributes?
  89   return GenericArg::create_const (
  90     std::unique_ptr<Expr> (new IdentifierExpr (path, {}, locus)));
  91 }
  92
  93 GenericArg
  94 GenericArg::disambiguate_to_type () const
  95 {
  96   rust_assert (get_kind () == Kind::Either);
  97
  98   auto segment = std::unique_ptr<TypePathSegment> (
  99     new TypePathSegment (path.as_string (), false, locus));
 100   auto segments = std::vector<std::unique_ptr<TypePathSegment>> ();
 101   segments.emplace_back (std::move (segment));
 102
 103   return GenericArg::create_type (
 104     std::unique_ptr<Type> (new TypePath (std::move (segments), locus)));
 105 }
 106
 107 std::string
 108 GenericArgsBinding::as_string () const
 109 {
 110   // TODO: rewrite to work with non-literalisable types
 111   return identifier.as_string () + " = " + type->as_string ();
 112 }
 113
 114 std::string
 115 ConstGenericParam::as_string () const
 116 {
 117   std::string str ("ConstGenericParam: ");
 118   str += "const " + name.as_string () + ": " + type->as_string ();
 119
 120   if (has_default_value ())
 121     str += " = " + get_default_value ().as_string ();
 122
 123   return str;
 124 }
 125
 126 std::string
 127 PathExprSegment::as_string () const
 128 {
 129   // TODO: rewrite dump to work with non-literalisable types
 130   std::string ident_str = segment_name.as_string ();
 131   if (has_generic_args ())
 132     ident_str += "::<" + generic_args.as_string () + ">";
 133
 134   return ident_str;
 135 }
 136
 137 std::string
 138 PathPattern::as_string () const
 139 {
 140   std::string str;
 141
 142   for (const auto &segment : segments)
 143     str += segment.as_string () + "::";
 144
 145   // basically a hack - remove last two characters of string (remove final ::)
 146   str.erase (str.length () - 2);
 147
 148   return str;
 149 }
 150
 151 SimplePath
 152 PathPattern::convert_to_simple_path (bool with_opening_scope_resolution) const
 153 {
 154   if (!has_segments ())
 155     return SimplePath::create_empty ();
 156
 157   // create vector of reserved size (to minimise reallocations)
 158   std::vector<SimplePathSegment> simple_segments;
 159   simple_segments.reserve (segments.size ());
 160
 161   for (const auto &segment : segments)
 162     {
 163       // return empty path if doesn't meet simple path segment requirements
 164       if (segment.is_error () || segment.has_generic_args ()
 165           || segment.as_string () == "Self")
 166         return SimplePath::create_empty ();
 167
 168       // create segment and add to vector
 169       std::string segment_str = segment.as_string ();
 170       simple_segments.push_back (
 171         SimplePathSegment (std::move (segment_str), segment.get_locus ()));
 172     }
 173
 174   // kind of a HACK to get locus depending on opening scope resolution
 175   location_t locus = UNKNOWN_LOCATION;
 176   if (with_opening_scope_resolution)
 177     locus = simple_segments[0].get_locus () - 2; // minus 2 chars for ::
 178   else
 179     locus = simple_segments[0].get_locus ();
 180   // FIXME: this hack probably doesn't actually work
 181
 182   return SimplePath (std::move (simple_segments), with_opening_scope_resolution,
 183                      locus);
 184 }
 185
 186 void
 187 PathInExpression::accept_vis (ASTVisitor &vis)
 188 {
 189   vis.visit (*this);
 190 }
 191
 192 std::string
 193 PathInExpression::as_string () const
 194 {
 195   std::string str;
 196
 197   if (has_opening_scope_resolution)
 198     str = "::";
 199
 200   return str + PathPattern::as_string ();
 201 }
 202
 203 std::string
 204 TypePathSegmentGeneric::as_string () const
 205 {
 206   // TODO: rewrite to work with non-linearisable types
 207   return TypePathSegment::as_string () + "<" + generic_args.as_string () + ">";
 208 }
 209
 210 std::string
 211 TypePathSegmentFunction::as_string () const
 212 {
 213   // TODO: rewrite to work with non-linearisable types
 214   return TypePathSegment::as_string () + function_path.as_string ();
 215 }
 216
 217 std::string
 218 TypePath::as_string () const
 219 {
 220   /* TODO: this may need to be rewritten if a segment (e.g. function) can't be
 221    * literalised */
 222   std::string str;
 223
 224   if (has_opening_scope_resolution)
 225     str = "::";
 226
 227   for (const auto &segment : segments)
 228     str += segment->as_string () + "::";
 229
 230   // kinda hack - remove last 2 '::' characters
 231   str.erase (str.length () - 2);
 232
 233   return str;
 234 }
 235
 236 SimplePath
 237 TypePath::as_simple_path () const
 238 {
 239   if (segments.empty ())
 240     return SimplePath::create_empty ();
 241
 242   // create vector of reserved size (to minimise reallocations)
 243   std::vector<SimplePathSegment> simple_segments;
 244   simple_segments.reserve (segments.size ());
 245
 246   for (const auto &segment : segments)
 247     {
 248       // return empty path if doesn't meet simple path segment requirements
 249       if (segment == nullptr || segment->is_error ()
 250           || !segment->is_ident_only () || segment->as_string () == "Self")
 251         return SimplePath::create_empty ();
 252
 253       // create segment and add to vector
 254       std::string segment_str = segment->as_string ();
 255       simple_segments.push_back (
 256         SimplePathSegment (std::move (segment_str), segment->get_locus ()));
 257     }
 258
 259   return SimplePath (std::move (simple_segments), has_opening_scope_resolution,
 260                      locus);
 261 }
 262
 263 // hopefully definition here will prevent circular dependency issue
 264 TraitBound *
 265 TypePath::to_trait_bound (bool in_parens) const
 266 {
 267   return new TraitBound (TypePath (*this), get_locus (), in_parens);
 268 }
 269
 270 std::string
 271 TypePathFunction::as_string () const
 272 {
 273   // TODO: rewrite to work with non-linearisable types
 274   std::string str ("(");
 275
 276   if (has_inputs ())
 277     {
 278       auto i = inputs.begin ();
 279       auto e = inputs.end ();
 280
 281       for (; i != e; i++)
 282         {
 283           str += (*i)->as_string ();
 284           if (e != i + 1)
 285             str += ", ";
 286         }
 287     }
 288
 289   str += ")";
 290
 291   if (has_return_type ())
 292     str += " -> " + return_type->as_string ();
 293
 294   return str;
 295 }
 296
 297 std::string
 298 QualifiedPathInExpression::as_string () const
 299 {
 300   return path_type.as_string () + "::" + PathPattern::as_string ();
 301 }
 302
 303 std::string
 304 QualifiedPathInType::as_string () const
 305 {
 306   /* TODO: this may need adjusting if segments (e.g. with functions) can't be
 307    * literalised */
 308   std::string str = path_type.as_string ();
 309
 310   str += "::" + associated_segment->as_string ();
 311   for (const auto &segment : segments)
 312     str += "::" + segment->as_string ();
 313
 314   return str;
 315 }
 316
 317 void
 318 ConstGenericParam::accept_vis (ASTVisitor &vis)
 319 {
 320   vis.visit (*this);
 321 }
 322
 323 void
 324 TypePathSegment::accept_vis (ASTVisitor &vis)
 325 {
 326   vis.visit (*this);
 327 }
 328
 329 void
 330 TypePathSegmentGeneric::accept_vis (ASTVisitor &vis)
 331 {
 332   vis.visit (*this);
 333 }
 334
 335 void
 336 TypePathSegmentFunction::accept_vis (ASTVisitor &vis)
 337 {
 338   vis.visit (*this);
 339 }
 340
 341 void
 342 TypePath::accept_vis (ASTVisitor &vis)
 343 {
 344   vis.visit (*this);
 345 }
 346
 347 void
 348 QualifiedPathInExpression::accept_vis (ASTVisitor &vis)
 349 {
 350   vis.visit (*this);
 351 }
 352
 353 void
 354 QualifiedPathInType::accept_vis (ASTVisitor &vis)
 355 {
 356   vis.visit (*this);
 357 }
 358
 359 } // namespace AST
 360 } // namespace Rust