github.com/nevalang/neva@v0.23.1-0.20240507185603-7696a9bb8dda/internal/compiler/parser/smoke_test/happypath/025_component.neva (about)

     1  component Doer() () {}
     2  
     3  pub component Doer() () {}
     4  
     5  component {}
     6  
     7  component {
     8  }
     9  
    10  component {
    11  
    12  }
    13  
    14  component { Doer() () {} }
    15  
    16  component {
    17      Doer() () {} }
    18  
    19  component { Doer() () {}
    20  }
    21  
    22  component {
    23      Doer() () {}
    24  }
    25  
    26  component { Doer<T>(x int) (y T) {} }
    27  
    28  component {
    29      Doer<T>(x int) (y T) {
    30      }
    31  }
    32  
    33  component {
    34      Doer<T>(x int) (y T) {
    35  
    36      }
    37  }
    38  
    39  component {
    40      Doer<T>(x int) (y T) {
    41      }
    42  }
    43  
    44  component {
    45      Doer<T>(x int) (y T) {
    46          nodes {}
    47      }
    48  }
    49  
    50  component {
    51      Doer<T>(x int) (y T) {
    52          nodes {
    53          }
    54      }
    55  }
    56  
    57  component {
    58      Doer<T>(x int) (y T) {
    59          nodes { absNode INode }
    60      }
    61  }
    62  
    63  component {
    64      Doer<T>(x int) (y T) {
    65          nodes {
    66              absNode INode }
    67      }
    68  }
    69  
    70  component {
    71      Doer<T>(x int) (y T) {
    72          nodes { absNode INode
    73          }
    74      }
    75  }
    76  
    77  component {
    78      Doer<T>(x int) (y T) {
    79          nodes {
    80              absNode INode
    81          }
    82      }
    83  }
    84  
    85  component {
    86      Doer<T>(x int) (y T) {
    87          nodes {
    88              simpleAbsNode INode
    89              absNodeWithTypeArgs INode<
    90                  int,
    91                  map<
    92                      string, vec<bool>
    93                  >
    94              >
    95          }
    96      }
    97  }
    98  
    99  component {
   100      Doer<T>(x int) (y T) {
   101          nodes { concreteNode  Node }
   102      }
   103  }
   104  
   105  component {
   106      Doer<T>(x int) (y T) {
   107          nodes {
   108              concreteNode  Node }
   109      }
   110  }
   111  
   112  component {
   113      Doer<T>(x int) (y T) {
   114          nodes { concreteNode  Node
   115          }
   116      }
   117  }
   118  
   119  component {
   120      Doer<T>(x int) (y T) {
   121          nodes {
   122              concreteNode  Node
   123          }
   124      }
   125  }
   126  
   127  component {
   128      Doer<T>(x int) (y T) {
   129          nodes {
   130              concreteNodeWithTypeArgs  Node<int, vec<string>>
   131          }
   132      }
   133  }
   134  
   135  component {
   136      Doer<T>(x int) (y T) {
   137          nodes {
   138              concreteNodeWithDI1  Node1{foo Node2}
   139              concreteNodeWithDI2  Node1{
   140                  foo Node2
   141                  bar Node3
   142              }
   143          }
   144      }
   145  }
   146  
   147  component {
   148      Doer<T>(x int) (y T) {
   149          nodes {
   150              concreteNodeWithDI1  Node1{
   151                  foo Node2
   152              }
   153              concreteNodeWithDI2  Node1{
   154                  foo Node2
   155                  bar Node3
   156              }
   157          }
   158      }
   159  }
   160  
   161  component {
   162      Doer<T>(x int) (y T) {
   163          nodes {
   164              concreteNodeWithDIAndTypeArgs  Node1<
   165                  int,
   166                  map<
   167                      string,
   168                      vec<bool>
   169                  >
   170              > {
   171                  foo Node2
   172                  bar Node3
   173              }
   174          }
   175      }
   176  }
   177  
   178  component {
   179      Doer<T>(x int) (y T) {
   180          nodes {
   181              simpleAbsNode INode
   182  
   183              absNodeWithTypeArgs INode<
   184                  int,
   185                  map<
   186                      string, vec<bool>
   187                  >
   188              >
   189  
   190              concreteNodeWithDI1  Node1{ foo Node2 }
   191  
   192              concreteNodeWithDIAndTypeArgs  Node1<
   193                  int,
   194                  map<
   195                      string,
   196                      vec<bool>
   197                  >
   198              >{
   199                  foo Node2
   200                  bar Node3
   201              }
   202          }
   203      }
   204  }
   205  
   206  component {
   207  	Main(start any) (stop any) {
   208  		nodes {
   209  			abs IReader
   210  			concrete  Scanner
   211  		}
   212          :start -> abs:v
   213          abs:v -> [concrete:v]
   214          concrete:v -> :code
   215  	}
   216  }
   217  
   218  component {
   219  	Main() () {
   220          $foo.bar -> foo:bar
   221          $foo.bar.baz -> foo:bar
   222          foo:bar.baz -> foo:bar
   223          foo:bar.baz.bax -> foo:bar
   224          $foo.bar.baz -> [foo:bar, bar:baz]
   225          foo:bar.baz.bax -> [
   226              foo:bar,
   227              bar:baz
   228          ]
   229  	}
   230  }
   231  
   232  component {
   233  	Main() () {
   234          $foo -> (foo:bar -> bar:baz)
   235  
   236          $foo -> [(foo:bar -> bar:baz),
   237          (foo:bar -> bar:baz)
   238          ]
   239  
   240          $foo -> [(foo:bar -> bar:baz),
   241              (foo:bar -> bar:baz)
   242          ]
   243  
   244          $foo -> [
   245              (foo:bar -> bar:baz),
   246              (foo:bar -> bar:baz)]
   247  
   248          $foo -> [
   249              (foo:bar -> bar:baz),
   250              (foo:bar -> bar:baz)
   251          ]
   252  	}
   253  }
   254  
   255  component {
   256  	Main() () {
   257          $a -> ($b -> ($c -> d:e))
   258  
   259          $a -> (
   260              $b -> ($c -> d:e)
   261          )
   262  
   263          $a -> (
   264              $b -> (
   265                  $c -> d:e
   266              )
   267          )
   268  	}
   269  }
   270  
   271  component Main(start) (stop) { :start -> :stop }
   272  
   273  component Main(start) (stop) {
   274      :start -> :stop }
   275  
   276  component Main(start) (stop) { :start -> :stop
   277  }
   278  
   279  component Main(start) (stop) {
   280      :start -> :stop
   281  }
   282  
   283  component Main() () {
   284      :foo -> :bar
   285      :baz -> :bax
   286  }
   287