api_predicates.go

     1  // Code generated by "go test -run=Generate -write=all"; DO NOT EDIT.
     2  // Source: ../../cmd/compile/internal/types2/api_predicates.go
     3  
     4  // Copyright 2023 The Go Authors. All rights reserved.
     5  // Use of this source code is governed by a BSD-style
     6  // license that can be found in the LICENSE file.
     7  
     8  // This file implements exported type predicates.
     9  
    10  package types
    11  
    12  // AssertableTo reports whether a value of type V can be asserted to have type T.
    13  //
    14  // The behavior of AssertableTo is unspecified in three cases:
    15  //   - if T is Typ[Invalid]
    16  //   - if V is a generalized interface; i.e., an interface that may only be used
    17  //     as a type constraint in Go code
    18  //   - if T is an uninstantiated generic type
    19  func AssertableTo(V *Interface, T Type) bool {
    20  	// Checker.newAssertableTo suppresses errors for invalid types, so we need special
    21  	// handling here.
    22  	if !isValid(T.Underlying()) {
    23  		return false
    24  	}
    25  	return (*Checker)(nil).newAssertableTo(V, T, nil)
    26  }
    27  
    28  // AssignableTo reports whether a value of type V is assignable to a variable
    29  // of type T.
    30  //
    31  // The behavior of AssignableTo is unspecified if V or T is Typ[Invalid] or an
    32  // uninstantiated generic type.
    33  func AssignableTo(V, T Type) bool {
    34  	x := operand{mode: value, typ: V}
    35  	ok, _ := x.assignableTo(nil, T, nil) // check not needed for non-constant x
    36  	return ok
    37  }
    38  
    39  // ConvertibleTo reports whether a value of type V is convertible to a value of
    40  // type T.
    41  //
    42  // The behavior of ConvertibleTo is unspecified if V or T is Typ[Invalid] or an
    43  // uninstantiated generic type.
    44  func ConvertibleTo(V, T Type) bool {
    45  	x := operand{mode: value, typ: V}
    46  	return x.convertibleTo(nil, T, nil) // check not needed for non-constant x
    47  }
    48  
    49  // Implements reports whether type V implements interface T.
    50  //
    51  // The behavior of Implements is unspecified if V is Typ[Invalid] or an uninstantiated
    52  // generic type.
    53  func Implements(V Type, T *Interface) bool {
    54  	if T.Empty() {
    55  		// All types (even Typ[Invalid]) implement the empty interface.
    56  		return true
    57  	}
    58  	// Checker.implements suppresses errors for invalid types, so we need special
    59  	// handling here.
    60  	if !isValid(V.Underlying()) {
    61  		return false
    62  	}
    63  	return (*Checker)(nil).implements(V, T, false, nil)
    64  }
    65  
    66  // Satisfies reports whether type V satisfies the constraint T.
    67  //
    68  // The behavior of Satisfies is unspecified if V is Typ[Invalid] or an uninstantiated
    69  // generic type.
    70  func Satisfies(V Type, T *Interface) bool {
    71  	return (*Checker)(nil).implements(V, T, true, nil)
    72  }
    73  
    74  // Identical reports whether x and y are identical types.
    75  // Receivers of [Signature] types are ignored.
    76  //
    77  // Predicates such as [Identical], [Implements], and
    78  // [Satisfies] assume that both operands belong to a
    79  // consistent collection of symbols ([Object] values).
    80  // For example, two [Named] types can be identical only if their
    81  // [Named.Obj] methods return the same [TypeName] symbol.
    82  // A collection of symbols is consistent if, for each logical
    83  // package whose path is P, the creation of those symbols
    84  // involved at most one call to [NewPackage](P, ...).
    85  // To ensure consistency, use a single [Importer] for
    86  // all loaded packages and their dependencies.
    87  // For more information, see https://github.com/golang/go/issues/57497.
    88  func Identical(x, y Type) bool {
    89  	var c comparer
    90  	return c.identical(x, y, nil)
    91  }
    92  
    93  // IdenticalIgnoreTags reports whether x and y are identical types if tags are ignored.
    94  // Receivers of [Signature] types are ignored.
    95  func IdenticalIgnoreTags(x, y Type) bool {
    96  	var c comparer
    97  	c.ignoreTags = true
    98  	return c.identical(x, y, nil)
    99  }
   100
View as plain text