gcc/rust/hir/rust-hir-dump.cc

   1 // Copyright (C) 2020-2023 Free Software Foundation, Inc.
   2
   3 // This file is part of GCC.
   4
   5 // GCC is free software; you can redistribute it and/or modify it under
   6 // the terms of the GNU General Public License as published by the Free
   7 // Software Foundation; either version 3, or (at your option) any later
   8 // version.
   9
  10 // GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  11 // WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12 // FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  13 // for more details.
  14
  15 // You should have received a copy of the GNU General Public License
  16 // along with GCC; see the file COPYING3.  If not see
  17 // <http://www.gnu.org/licenses/>.
  18
  19 #include "rust-hir-dump.h"
  20
  21 namespace Rust {
  22 namespace HIR {
  23
  24 Dump::Dump (std::ostream &stream) : stream (stream), indent (0) {}
  25
  26 void
  27 Dump::go (HIR::Crate &crate)
  28 {
  29   stream << "Crate"
  30          << " "
  31          << "{" << std::endl;
  32   //
  33
  34   indent++;
  35   stream << std::string (indent, indent_char);
  36   stream << "inner_attrs"
  37          << ":"
  38          << " "
  39          << "[";
  40   for (auto &attr : crate.inner_attrs)
  41     stream << attr.as_string ();
  42   stream << "]"
  43          << "," << std::endl;
  44   indent--;
  45
  46   indent++;
  47   stream << std::string (indent, indent_char);
  48   //
  49
  50   stream << "items"
  51          << ":"
  52          << " "
  53          << "[";
  54
  55   stream << std::string (indent, indent_char);
  56   for (const auto &item : crate.items)
  57     {
  58       stream << std::endl;
  59       item->accept_vis (*this);
  60     }
  61   stream << std::string (indent, indent_char);
  62   stream << "]"
  63          << "," << std::endl;
  64   indent--;
  65   //
  66
  67   indent++;
  68   stream << std::string (indent, indent_char);
  69   stream << "node_mappings"
  70          << ":"
  71          << " "
  72          << "[";
  73   // TODO: print crate mapping attrs
  74   stream << "]" << std::endl;
  75   indent--;
  76
  77   stream << "}" << std::endl;
  78 }
  79
  80 void
  81 Dump::visit (Lifetime &)
  82 {}
  83 void
  84 Dump::visit (LifetimeParam &)
  85 {}
  86 void
  87 Dump::visit (PathInExpression &)
  88 {}
  89 void
  90 Dump::visit (TypePathSegment &)
  91 {}
  92 void
  93 Dump::visit (TypePathSegmentGeneric &)
  94 {}
  95 void
  96 Dump::visit (TypePathSegmentFunction &)
  97 {}
  98 void
  99 Dump::visit (TypePath &)
 100 {}
 101 void
 102 Dump::visit (QualifiedPathInExpression &)
 103 {}
 104 void
 105 Dump::visit (QualifiedPathInType &)
 106 {}
 107
 108 void
 109 Dump::visit (LiteralExpr &literal_expr)
 110 {
 111   indent++;
 112   stream << std::string (indent, indent_char);
 113   stream << "( " + literal_expr.get_literal ().as_string () + " ("
 114               + literal_expr.get_mappings ().as_string () + "))";
 115   stream << "\n";
 116 }
 117 void
 118 Dump::visit (BorrowExpr &)
 119 {}
 120 void
 121 Dump::visit (DereferenceExpr &)
 122 {}
 123 void
 124 Dump::visit (ErrorPropagationExpr &)
 125 {}
 126 void
 127 Dump::visit (NegationExpr &)
 128 {}
 129 void
 130 Dump::visit (ArithmeticOrLogicalExpr &)
 131 {}
 132 void
 133 Dump::visit (ComparisonExpr &)
 134 {}
 135 void
 136 Dump::visit (LazyBooleanExpr &)
 137 {}
 138 void
 139 Dump::visit (TypeCastExpr &)
 140 {}
 141 void
 142 Dump::visit (AssignmentExpr &)
 143 {}
 144 void
 145 Dump::visit (CompoundAssignmentExpr &)
 146 {}
 147 void
 148 Dump::visit (GroupedExpr &)
 149 {}
 150
 151 void
 152 Dump::visit (ArrayElemsValues &)
 153 {}
 154 void
 155 Dump::visit (ArrayElemsCopied &)
 156 {}
 157 void
 158 Dump::visit (ArrayExpr &)
 159 {}
 160 void
 161 Dump::visit (ArrayIndexExpr &)
 162 {}
 163 void
 164 Dump::visit (TupleExpr &)
 165 {}
 166 void
 167 Dump::visit (TupleIndexExpr &)
 168 {}
 169 void
 170 Dump::visit (StructExprStruct &)
 171 {}
 172
 173 void
 174 Dump::visit (StructExprFieldIdentifier &)
 175 {}
 176 void
 177 Dump::visit (StructExprFieldIdentifierValue &)
 178 {}
 179
 180 void
 181 Dump::visit (StructExprFieldIndexValue &)
 182 {}
 183 void
 184 Dump::visit (StructExprStructFields &)
 185 {}
 186 void
 187 Dump::visit (StructExprStructBase &)
 188 {}
 189
 190 void
 191 Dump::visit (CallExpr &)
 192 {}
 193 void
 194 Dump::visit (MethodCallExpr &)
 195 {}
 196 void
 197 Dump::visit (FieldAccessExpr &)
 198 {}
 199 void
 200 Dump::visit (ClosureExpr &)
 201 {}
 202 void
 203 Dump::visit (BlockExpr &)
 204 {
 205   stream << "BlockExpr"
 206          << ":"
 207          << " "
 208          << "[";
 209   indent++;
 210   // TODO: print statements
 211   // TODO: print tail expression if exists
 212   stream << "]";
 213   indent--;
 214 }
 215
 216 void
 217 Dump::visit (ContinueExpr &)
 218 {}
 219 void
 220 Dump::visit (BreakExpr &)
 221 {}
 222 void
 223 Dump::visit (RangeFromToExpr &)
 224 {}
 225 void
 226 Dump::visit (RangeFromExpr &)
 227 {}
 228 void
 229 Dump::visit (RangeToExpr &)
 230 {}
 231 void
 232 Dump::visit (RangeFullExpr &)
 233 {}
 234 void
 235 Dump::visit (RangeFromToInclExpr &)
 236 {}
 237 void
 238 Dump::visit (RangeToInclExpr &)
 239 {}
 240 void
 241 Dump::visit (ReturnExpr &)
 242 {}
 243 void
 244 Dump::visit (UnsafeBlockExpr &)
 245 {}
 246 void
 247 Dump::visit (LoopExpr &)
 248 {}
 249 void
 250 Dump::visit (WhileLoopExpr &)
 251 {}
 252 void
 253 Dump::visit (WhileLetLoopExpr &)
 254 {}
 255 void
 256 Dump::visit (ForLoopExpr &)
 257 {}
 258 void
 259 Dump::visit (IfExpr &)
 260 {}
 261 void
 262 Dump::visit (IfExprConseqElse &)
 263 {}
 264 void
 265 Dump::visit (IfExprConseqIf &)
 266 {}
 267 void
 268 Dump::visit (IfExprConseqIfLet &)
 269 {}
 270 void
 271 Dump::visit (IfLetExpr &)
 272 {}
 273 void
 274 Dump::visit (IfLetExprConseqElse &)
 275 {}
 276 void
 277 Dump::visit (IfLetExprConseqIf &)
 278 {}
 279 void
 280 Dump::visit (IfLetExprConseqIfLet &)
 281 {}
 282
 283 void
 284 Dump::visit (MatchExpr &)
 285 {}
 286 void
 287 Dump::visit (AwaitExpr &)
 288 {}
 289 void
 290 Dump::visit (AsyncBlockExpr &)
 291 {}
 292
 293 void
 294 Dump::visit (TypeParam &)
 295 {}
 296
 297 void
 298 Dump::visit (ConstGenericParam &)
 299 {}
 300
 301 void
 302 Dump::visit (LifetimeWhereClauseItem &)
 303 {}
 304 void
 305 Dump::visit (TypeBoundWhereClauseItem &)
 306 {}
 307 void
 308 Dump::visit (Module &)
 309 {}
 310 void
 311 Dump::visit (ExternCrate &)
 312 {}
 313
 314 void
 315 Dump::visit (UseTreeGlob &)
 316 {}
 317 void
 318 Dump::visit (UseTreeList &)
 319 {}
 320 void
 321 Dump::visit (UseTreeRebind &)
 322 {}
 323 void
 324 Dump::visit (UseDeclaration &)
 325 {}
 326 void
 327 Dump::visit (Function &)
 328 {
 329   indent++;
 330   stream << std::string (indent, indent_char);
 331   stream << "Function"
 332          << " ";
 333   stream << "{" << std::endl;
 334   // TODO: print function params
 335   stream << std::string (indent, indent_char);
 336   stream << "}" << std::endl;
 337   // TODO: get function definition and visit block
 338
 339   stream << std::endl;
 340   indent--;
 341 }
 342 void
 343 Dump::visit (TypeAlias &)
 344 {}
 345 void
 346 Dump::visit (StructStruct &)
 347 {}
 348 void
 349 Dump::visit (TupleStruct &)
 350 {}
 351 void
 352 Dump::visit (EnumItem &)
 353 {}
 354 void
 355 Dump::visit (EnumItemTuple &)
 356 {}
 357 void
 358 Dump::visit (EnumItemStruct &)
 359 {}
 360 void
 361 Dump::visit (EnumItemDiscriminant &)
 362 {}
 363 void
 364 Dump::visit (Enum &)
 365 {}
 366 void
 367 Dump::visit (Union &)
 368 {}
 369 void
 370 Dump::visit (ConstantItem &)
 371 {}
 372 void
 373 Dump::visit (StaticItem &)
 374 {}
 375 void
 376 Dump::visit (TraitItemFunc &)
 377 {}
 378 void
 379 Dump::visit (TraitItemConst &)
 380 {}
 381 void
 382 Dump::visit (TraitItemType &)
 383 {}
 384 void
 385 Dump::visit (Trait &)
 386 {}
 387 void
 388 Dump::visit (ImplBlock &)
 389 {}
 390
 391 void
 392 Dump::visit (ExternalStaticItem &)
 393 {}
 394 void
 395 Dump::visit (ExternalFunctionItem &)
 396 {}
 397 void
 398 Dump::visit (ExternBlock &)
 399 {}
 400
 401 void
 402 Dump::visit (LiteralPattern &)
 403 {}
 404 void
 405 Dump::visit (IdentifierPattern &)
 406 {}
 407 void
 408 Dump::visit (WildcardPattern &)
 409 {}
 410
 411 void
 412 Dump::visit (RangePatternBoundLiteral &)
 413 {}
 414 void
 415 Dump::visit (RangePatternBoundPath &)
 416 {}
 417 void
 418 Dump::visit (RangePatternBoundQualPath &)
 419 {}
 420 void
 421 Dump::visit (RangePattern &)
 422 {}
 423 void
 424 Dump::visit (ReferencePattern &)
 425 {}
 426
 427 void
 428 Dump::visit (StructPatternFieldTuplePat &)
 429 {}
 430 void
 431 Dump::visit (StructPatternFieldIdentPat &)
 432 {}
 433 void
 434 Dump::visit (StructPatternFieldIdent &)
 435 {}
 436 void
 437 Dump::visit (StructPattern &)
 438 {}
 439
 440 void
 441 Dump::visit (TupleStructItemsNoRange &)
 442 {}
 443 void
 444 Dump::visit (TupleStructItemsRange &)
 445 {}
 446 void
 447 Dump::visit (TupleStructPattern &)
 448 {}
 449
 450 void
 451 Dump::visit (TuplePatternItemsMultiple &)
 452 {}
 453 void
 454 Dump::visit (TuplePatternItemsRanged &)
 455 {}
 456 void
 457 Dump::visit (TuplePattern &)
 458 {}
 459 void
 460 Dump::visit (SlicePattern &)
 461 {}
 462
 463 void
 464 Dump::visit (EmptyStmt &)
 465 {}
 466 void
 467 Dump::visit (LetStmt &)
 468 {}
 469 void
 470 Dump::visit (ExprStmtWithoutBlock &)
 471 {}
 472 void
 473 Dump::visit (ExprStmtWithBlock &)
 474 {}
 475
 476 void
 477 Dump::visit (TraitBound &)
 478 {}
 479 void
 480 Dump::visit (ImplTraitType &)
 481 {}
 482 void
 483 Dump::visit (TraitObjectType &)
 484 {}
 485 void
 486 Dump::visit (ParenthesisedType &)
 487 {}
 488 void
 489 Dump::visit (ImplTraitTypeOneBound &)
 490 {}
 491 void
 492 Dump::visit (TupleType &)
 493 {}
 494 void
 495 Dump::visit (NeverType &)
 496 {}
 497 void
 498 Dump::visit (RawPointerType &)
 499 {}
 500 void
 501 Dump::visit (ReferenceType &)
 502 {}
 503 void
 504 Dump::visit (ArrayType &)
 505 {}
 506 void
 507 Dump::visit (SliceType &)
 508 {}
 509 void
 510 Dump::visit (InferredType &)
 511 {}
 512 void
 513 Dump::visit (BareFunctionType &)
 514 {}
 515 } // namespace HIR
 516 } // namespace Rust