returns.go

     1  // Copyright 2023 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  // DO NOT EDIT (use 'go test -v -update-expected' instead.)
     6  // See cmd/compile/internal/inline/inlheur/testdata/props/README.txt
     7  // for more information on the format of this file.
     8  // <endfilepreamble>
     9  
    10  package returns1
    11  
    12  import "unsafe"
    13  
    14  // returns.go T_simple_allocmem 21 0 1
    15  // ResultFlags
    16  //   0 ResultIsAllocatedMem
    17  // <endpropsdump>
    18  // {"Flags":0,"ParamFlags":null,"ResultFlags":[2]}
    19  // <endcallsites>
    20  // <endfuncpreamble>
    21  func T_simple_allocmem() *Bar {
    22  	return &Bar{}
    23  }
    24  
    25  // returns.go T_allocmem_two_returns 34 0 1
    26  // ParamFlags
    27  //   0 ParamFeedsIfOrSwitch
    28  // ResultFlags
    29  //   0 ResultIsAllocatedMem
    30  // <endpropsdump>
    31  // {"Flags":0,"ParamFlags":[32],"ResultFlags":[2]}
    32  // <endcallsites>
    33  // <endfuncpreamble>
    34  func T_allocmem_two_returns(x int) *Bar {
    35  	// multiple returns
    36  	if x < 0 {
    37  		return new(Bar)
    38  	} else {
    39  		return &Bar{x: 2}
    40  	}
    41  }
    42  
    43  // returns.go T_allocmem_three_returns 52 0 1
    44  // ParamFlags
    45  //   0 ParamFeedsIfOrSwitch
    46  // ResultFlags
    47  //   0 ResultIsAllocatedMem
    48  // <endpropsdump>
    49  // {"Flags":0,"ParamFlags":[32],"ResultFlags":[2]}
    50  // <endcallsites>
    51  // <endfuncpreamble>
    52  func T_allocmem_three_returns(x int) []*Bar {
    53  	// more multiple returns
    54  	switch x {
    55  	case 10, 11, 12:
    56  		return make([]*Bar, 10)
    57  	case 13:
    58  		fallthrough
    59  	case 15:
    60  		return []*Bar{&Bar{x: 15}}
    61  	}
    62  	return make([]*Bar, 0, 10)
    63  }
    64  
    65  // returns.go T_return_nil 72 0 1
    66  // ResultFlags
    67  //   0 ResultAlwaysSameConstant
    68  // <endpropsdump>
    69  // {"Flags":0,"ParamFlags":null,"ResultFlags":[8]}
    70  // <endcallsites>
    71  // <endfuncpreamble>
    72  func T_return_nil() *Bar {
    73  	// simple case: no alloc
    74  	return nil
    75  }
    76  
    77  // returns.go T_multi_return_nil 84 0 1
    78  // ResultFlags
    79  //   0 ResultAlwaysSameConstant
    80  // <endpropsdump>
    81  // {"Flags":0,"ParamFlags":[0,0],"ResultFlags":[8]}
    82  // <endcallsites>
    83  // <endfuncpreamble>
    84  func T_multi_return_nil(x, y bool) *Bar {
    85  	if x && y {
    86  		return nil
    87  	}
    88  	return nil
    89  }
    90  
    91  // returns.go T_multi_return_nil_anomaly 98 0 1
    92  // ResultFlags
    93  //   0 ResultIsConcreteTypeConvertedToInterface
    94  // <endpropsdump>
    95  // {"Flags":0,"ParamFlags":[0,0],"ResultFlags":[4]}
    96  // <endcallsites>
    97  // <endfuncpreamble>
    98  func T_multi_return_nil_anomaly(x, y bool) Itf {
    99  	if x && y {
   100  		var qnil *Q
   101  		return qnil
   102  	}
   103  	var barnil *Bar
   104  	return barnil
   105  }
   106  
   107  // returns.go T_multi_return_some_nil 112 0 1
   108  // <endpropsdump>
   109  // {"Flags":0,"ParamFlags":[0,0],"ResultFlags":[0]}
   110  // <endcallsites>
   111  // <endfuncpreamble>
   112  func T_multi_return_some_nil(x, y bool) *Bar {
   113  	if x && y {
   114  		return nil
   115  	} else {
   116  		return &GB
   117  	}
   118  }
   119  
   120  // returns.go T_mixed_returns 127 0 1
   121  // ParamFlags
   122  //   0 ParamFeedsIfOrSwitch
   123  // <endpropsdump>
   124  // {"Flags":0,"ParamFlags":[32],"ResultFlags":[0]}
   125  // <endcallsites>
   126  // <endfuncpreamble>
   127  func T_mixed_returns(x int) *Bar {
   128  	// mix of alloc and non-alloc
   129  	if x < 0 {
   130  		return new(Bar)
   131  	} else {
   132  		return &GB
   133  	}
   134  }
   135  
   136  // returns.go T_mixed_returns_slice 143 0 1
   137  // ParamFlags
   138  //   0 ParamFeedsIfOrSwitch
   139  // <endpropsdump>
   140  // {"Flags":0,"ParamFlags":[32],"ResultFlags":[0]}
   141  // <endcallsites>
   142  // <endfuncpreamble>
   143  func T_mixed_returns_slice(x int) []*Bar {
   144  	// mix of alloc and non-alloc
   145  	switch x {
   146  	case 10, 11, 12:
   147  		return make([]*Bar, 10)
   148  	case 13:
   149  		fallthrough
   150  	case 15:
   151  		return []*Bar{&Bar{x: 15}}
   152  	}
   153  	ba := [...]*Bar{&GB, &GB}
   154  	return ba[:]
   155  }
   156  
   157  // returns.go T_maps_and_channels 167 0 1
   158  // ResultFlags
   159  //   0 ResultNoInfo
   160  //   1 ResultNoInfo
   161  //   2 ResultNoInfo
   162  //   3 ResultAlwaysSameConstant
   163  // <endpropsdump>
   164  // {"Flags":0,"ParamFlags":[0,0],"ResultFlags":[0,0,0,8]}
   165  // <endcallsites>
   166  // <endfuncpreamble>
   167  func T_maps_and_channels(x int, b bool) (bool, map[int]int, chan bool, unsafe.Pointer) {
   168  	// maps and channels
   169  	return b, make(map[int]int), make(chan bool), nil
   170  }
   171  
   172  // returns.go T_assignment_to_named_returns 179 0 1
   173  // ParamFlags
   174  //   0 ParamFeedsIfOrSwitch
   175  // <endpropsdump>
   176  // {"Flags":0,"ParamFlags":[32],"ResultFlags":[0,0]}
   177  // <endcallsites>
   178  // <endfuncpreamble>
   179  func T_assignment_to_named_returns(x int) (r1 *uint64, r2 *uint64) {
   180  	// assignments to named returns and then "return" not supported
   181  	r1 = new(uint64)
   182  	if x < 1 {
   183  		*r1 = 2
   184  	}
   185  	r2 = new(uint64)
   186  	return
   187  }
   188  
   189  // returns.go T_named_returns_but_return_explicit_values 199 0 1
   190  // ParamFlags
   191  //   0 ParamFeedsIfOrSwitch
   192  // ResultFlags
   193  //   0 ResultIsAllocatedMem
   194  //   1 ResultIsAllocatedMem
   195  // <endpropsdump>
   196  // {"Flags":0,"ParamFlags":[32],"ResultFlags":[2,2]}
   197  // <endcallsites>
   198  // <endfuncpreamble>
   199  func T_named_returns_but_return_explicit_values(x int) (r1 *uint64, r2 *uint64) {
   200  	// named returns ok if all returns are non-empty
   201  	rx1 := new(uint64)
   202  	if x < 1 {
   203  		*rx1 = 2
   204  	}
   205  	rx2 := new(uint64)
   206  	return rx1, rx2
   207  }
   208  
   209  // returns.go T_return_concrete_type_to_itf 216 0 1
   210  // ResultFlags
   211  //   0 ResultIsConcreteTypeConvertedToInterface
   212  // <endpropsdump>
   213  // {"Flags":0,"ParamFlags":[0,0],"ResultFlags":[4]}
   214  // <endcallsites>
   215  // <endfuncpreamble>
   216  func T_return_concrete_type_to_itf(x, y int) Itf {
   217  	return &Bar{}
   218  }
   219  
   220  // returns.go T_return_concrete_type_to_itfwith_copy 227 0 1
   221  // ResultFlags
   222  //   0 ResultIsConcreteTypeConvertedToInterface
   223  // <endpropsdump>
   224  // {"Flags":0,"ParamFlags":[0,0],"ResultFlags":[4]}
   225  // <endcallsites>
   226  // <endfuncpreamble>
   227  func T_return_concrete_type_to_itfwith_copy(x, y int) Itf {
   228  	b := &Bar{}
   229  	println("whee")
   230  	return b
   231  }
   232  
   233  // returns.go T_return_concrete_type_to_itf_mixed 238 0 1
   234  // <endpropsdump>
   235  // {"Flags":0,"ParamFlags":[0,0],"ResultFlags":[0]}
   236  // <endcallsites>
   237  // <endfuncpreamble>
   238  func T_return_concrete_type_to_itf_mixed(x, y int) Itf {
   239  	if x < y {
   240  		b := &Bar{}
   241  		return b
   242  	}
   243  	return nil
   244  }
   245  
   246  // returns.go T_return_same_func 253 0 1
   247  // ResultFlags
   248  //   0 ResultAlwaysSameInlinableFunc
   249  // <endpropsdump>
   250  // {"Flags":0,"ParamFlags":null,"ResultFlags":[32]}
   251  // <endcallsites>
   252  // <endfuncpreamble>
   253  func T_return_same_func() func(int) int {
   254  	if G < 10 {
   255  		return foo
   256  	} else {
   257  		return foo
   258  	}
   259  }
   260  
   261  // returns.go T_return_different_funcs 266 0 1
   262  // <endpropsdump>
   263  // {"Flags":0,"ParamFlags":null,"ResultFlags":[0]}
   264  // <endcallsites>
   265  // <endfuncpreamble>
   266  func T_return_different_funcs() func(int) int {
   267  	if G != 10 {
   268  		return foo
   269  	} else {
   270  		return bar
   271  	}
   272  }
   273  
   274  // returns.go T_return_same_closure 286 0 1
   275  // ResultFlags
   276  //   0 ResultAlwaysSameInlinableFunc
   277  // <endpropsdump>
   278  // {"Flags":0,"ParamFlags":null,"ResultFlags":[32]}
   279  // <endcallsites>
   280  // <endfuncpreamble>
   281  // returns.go T_return_same_closure.func1 287 0 1
   282  // <endpropsdump>
   283  // {"Flags":0,"ParamFlags":[0],"ResultFlags":[0]}
   284  // <endcallsites>
   285  // <endfuncpreamble>
   286  func T_return_same_closure() func(int) int {
   287  	p := func(q int) int { return q }
   288  	if G < 10 {
   289  		return p
   290  	} else {
   291  		return p
   292  	}
   293  }
   294  
   295  // returns.go T_return_different_closures 312 0 1
   296  // <endpropsdump>
   297  // {"Flags":0,"ParamFlags":null,"ResultFlags":[0]}
   298  // <endcallsites>
   299  // <endfuncpreamble>
   300  // returns.go T_return_different_closures.func1 313 0 1
   301  // <endpropsdump>
   302  // {"Flags":0,"ParamFlags":[0],"ResultFlags":[0]}
   303  // <endcallsites>
   304  // <endfuncpreamble>
   305  // returns.go T_return_different_closures.func2 317 0 1
   306  // ResultFlags
   307  //   0 ResultAlwaysSameConstant
   308  // <endpropsdump>
   309  // {"Flags":0,"ParamFlags":[0],"ResultFlags":[8]}
   310  // <endcallsites>
   311  // <endfuncpreamble>
   312  func T_return_different_closures() func(int) int {
   313  	p := func(q int) int { return q }
   314  	if G < 10 {
   315  		return p
   316  	} else {
   317  		return func(q int) int { return 101 }
   318  	}
   319  }
   320  
   321  // returns.go T_return_noninlinable 339 0 1
   322  // ResultFlags
   323  //   0 ResultAlwaysSameFunc
   324  // <endpropsdump>
   325  // {"Flags":0,"ParamFlags":[0],"ResultFlags":[16]}
   326  // <endcallsites>
   327  // <endfuncpreamble>
   328  // returns.go T_return_noninlinable.func1 340 0 1
   329  // <endpropsdump>
   330  // {"Flags":0,"ParamFlags":[0],"ResultFlags":[0]}
   331  // callsite: returns.go:343:4|0 flagstr "" flagval 0 score 4 mask 0 maskstr ""
   332  // <endcallsites>
   333  // <endfuncpreamble>
   334  // returns.go T_return_noninlinable.func1.1 341 0 1
   335  // <endpropsdump>
   336  // {"Flags":0,"ParamFlags":null,"ResultFlags":null}
   337  // <endcallsites>
   338  // <endfuncpreamble>
   339  func T_return_noninlinable(x int) func(int) int {
   340  	noti := func(q int) int {
   341  		defer func() {
   342  			println(q + x)
   343  		}()
   344  		return q
   345  	}
   346  	return noti
   347  }
   348  
   349  type Bar struct {
   350  	x int
   351  	y string
   352  }
   353  
   354  func (b *Bar) Plark() {
   355  }
   356  
   357  type Q int
   358  
   359  func (q *Q) Plark() {
   360  }
   361  
   362  func foo(x int) int { return x }
   363  func bar(x int) int { return -x }
   364  
   365  var G int
   366  var GB Bar
   367  
   368  type Itf interface {
   369  	Plark()
   370  }
   371
View as plain text