File: moveonly_generics_basic.swift

package info (click to toggle)
swiftlang 6.0.3-2
  • links: PTS, VCS
  • area: main
  • in suites: forky, sid, trixie
  • size: 2,519,992 kB
  • sloc: cpp: 9,107,863; ansic: 2,040,022; asm: 1,135,751; python: 296,500; objc: 82,456; f90: 60,502; lisp: 34,951; pascal: 19,946; sh: 18,133; perl: 7,482; ml: 4,937; javascript: 4,117; makefile: 3,840; awk: 3,535; xml: 914; fortran: 619; cs: 573; ruby: 573
file content (73 lines) | stat: -rw-r--r-- 2,138 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
// RUN: %target-swift-frontend %s -sil-verify-all -verify -emit-sil -enable-experimental-feature MoveOnlyPartialReinitialization

// REQUIRES: asserts


/// MARK: types

struct FileDescriptor: ~Copyable { let fd: Int = 0 }

struct Wrap<T: ~Copyable>: ~Copyable {
  var item: T
  init(_ t: consuming T) { self.item = t }
}
extension Wrap: Copyable where T: Copyable {}

/// MARK: utilities

func borrowAny<T: ~Copyable>(_ t: borrowing T) {}

/// MARK: tests

func barebones() {
  let nc = FileDescriptor() // expected-error {{'nc' consumed more than once}}
  borrowAny(nc)
  let _ = nc // expected-note {{consumed}}
  let _ = nc // expected-note {{consumed}}

  let cpWrap = Wrap(100)
  borrowAny(cpWrap)
  let _ = cpWrap
  let _ = cpWrap

  let ncWrap = Wrap(FileDescriptor()) // expected-error {{'ncWrap' consumed more than once}}
  borrowAny(ncWrap)
  let _ = ncWrap // expected-note {{consumed}}
  let _ = ncWrap // expected-note {{consumed}}
}

func test1<T: ~Copyable>(_ t: consuming T, // expected-error {{'t' consumed more than once}}
                                           // expected-error@-1 {{'t' used after consume}}
                         _ borrowArg: borrowing T) -> Wrap<T> {
                         // expected-error@-1 {{'borrowArg' is borrowed and cannot be consumed}}
  borrowAny(t)
  borrowAny(borrowArg)

  let wrap1 = Wrap(t) // expected-note {{consumed}}
  let _ = Wrap(t)     // expected-note 2{{consumed}}

  let _ = Wrap(borrowArg) // expected-note {{consumed}}

  borrowAny(t) // expected-note {{used}}
  borrowAny(borrowArg)

  return wrap1
}

func testWrap<T: ~Copyable>(_ x: borrowing Wrap<T>,
                             // expected-error@-1 {{'x' is borrowed and cannot be consumed}}
                            _ y: consuming Wrap<T>,
                            _ new: () -> T) -> T {
  _ = x.item // expected-note {{consumed}}

  // expected-error@+1 {{'result' consumed more than once}}
  let result = { (v: inout Wrap<T>) -> T in
   let result = v.item
   v.item = new()
   return result
  }(&y)

  let _ = result // expected-note {{consumed}}

  return result // expected-note {{consumed}}
}