AST: add enum FunctionTypeRepresentation and TypeProperties.functionTypeRepresentation

Author: eeckstein

SwiftCompilerSources/Sources/AST/Type.swift

@@ -227,6 +227,25 @@ extension TypeProperties {
     GenericSignature(bridged: rawType.bridged.getInvocationGenericSignatureOfFunctionType())
   }
 
+  public var functionTypeRepresentation: FunctionTypeRepresentation {
+    switch rawType.bridged.getFunctionTypeRepresentation() {
+      case .Thick:                 return .thick
+      case .Block:                 return .block
+      case .Thin:                  return .thin
+      case .CFunctionPointer:      return .cFunctionPointer
+      case .Method:                return .method
+      case .ObjCMethod:            return .objCMethod
+      case .WitnessMethod:         return .witnessMethod
+      case .Closure:               return .closure
+      case .CXXMethod:             return .cxxMethod
+      case .KeyPathAccessorGetter: return .keyPathAccessorGetter
+      case .KeyPathAccessorSetter: return .keyPathAccessorSetter
+      case .KeyPathAccessorEquals: return .keyPathAccessorEquals
+      case .KeyPathAccessorHash:   return .keyPathAccessorHash
+      default: fatalError()
+    }
+  }
+
   //===--------------------------------------------------------------------===//
   //                             Type properties
   //===--------------------------------------------------------------------===//
@@ -307,6 +326,59 @@ extension TypeProperties {
   }
 }
 
+public enum FunctionTypeRepresentation {
+  /// A freestanding thick function.
+  case thick
+
+  /// A thick function that is represented as an Objective-C block.
+  case block
+
+  /// A freestanding thin function that needs no context.
+  case thin
+
+  /// A C function pointer, which is thin and also uses the C calling convention.
+  case cFunctionPointer
+
+  /// A Swift instance method.
+  case method
+
+  /// An Objective-C method.
+  case objCMethod
+
+  /// A Swift protocol witness.
+  case witnessMethod
+
+  /// A closure invocation function that has not been bound to a context.
+  case closure
+
+  /// A C++ method that takes a "this" argument (not a static C++ method or constructor).
+  /// Except for handling the "this" argument, has the same behavior as "CFunctionPointer".
+  case cxxMethod
+
+  /// A KeyPath accessor function, which is thin and also uses the variadic length generic
+  /// components serialization in trailing buffer. Each representation has a different convention
+  /// for which parameters have serialized generic type info.
+  case keyPathAccessorGetter, keyPathAccessorSetter, keyPathAccessorEquals, keyPathAccessorHash
+
+  public var bridged: BridgedASTType.FunctionTypeRepresentation {
+    switch self {
+      case .thick:                 return .Thick
+      case .block:                 return .Block
+      case .thin:                  return .Thin
+      case .cFunctionPointer:      return .CFunctionPointer
+      case .method:                return .Method
+      case .objCMethod:            return .ObjCMethod
+      case .witnessMethod:         return .WitnessMethod
+      case .closure:               return .Closure
+      case .cxxMethod:             return .CXXMethod
+      case .keyPathAccessorGetter: return .KeyPathAccessorGetter
+      case .keyPathAccessorSetter: return .KeyPathAccessorSetter
+      case .keyPathAccessorEquals: return .KeyPathAccessorEquals
+      case .keyPathAccessorHash:   return .KeyPathAccessorHash
+    }
+  }
+}
+
 public struct TypeArray : RandomAccessCollection, CustomReflectable {
   public let bridged: BridgedASTTypeArray
 

include/swift/AST/ASTBridging.h

@@ -2985,6 +2985,22 @@ struct BridgedASTType {
     ObjC
   };
 
+  enum class FunctionTypeRepresentation {
+    Thick = 0,
+    Block,
+    Thin,
+    CFunctionPointer,
+    Method = 8,
+    ObjCMethod,
+    WitnessMethod,
+    Closure,
+    CXXMethod,
+    KeyPathAccessorGetter,
+    KeyPathAccessorSetter,
+    KeyPathAccessorEquals,
+    KeyPathAccessorHash
+  };
+
   swift::TypeBase * _Nullable type;
 
   BRIDGED_INLINE swift::Type unbridged() const;
@@ -3047,6 +3063,7 @@ struct BridgedASTType {
   BRIDGED_INLINE BridgedOptionalInt getValueOfIntegerType() const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedSubstitutionMap getContextSubstitutionMap() const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedGenericSignature getInvocationGenericSignatureOfFunctionType() const;
+  BRIDGED_INLINE FunctionTypeRepresentation getFunctionTypeRepresentation() const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedASTType subst(BridgedSubstitutionMap substMap) const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedASTType mapOutOfEnvironment() const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedCanType

include/swift/AST/ASTBridgingImpl.h

@@ -713,6 +713,25 @@ BridgedGenericSignature BridgedASTType::getInvocationGenericSignatureOfFunctionT
   return {unbridged()->castTo<swift::SILFunctionType>()->getInvocationGenericSignature().getPointer()};
 }
 
+BridgedASTType::FunctionTypeRepresentation BridgedASTType::getFunctionTypeRepresentation() const {
+  static_assert((int)FunctionTypeRepresentation::Thick == (int)swift::SILFunctionTypeRepresentation::Thick);
+  static_assert((int)FunctionTypeRepresentation::Block == (int)swift::SILFunctionTypeRepresentation::Block);
+  static_assert((int)FunctionTypeRepresentation::Thin == (int)swift::SILFunctionTypeRepresentation::Thin);
+  static_assert((int)FunctionTypeRepresentation::CFunctionPointer == (int)swift::SILFunctionTypeRepresentation::CFunctionPointer);
+  static_assert((int)FunctionTypeRepresentation::Method == (int)swift::SILFunctionTypeRepresentation::Method);
+  static_assert((int)FunctionTypeRepresentation::ObjCMethod == (int)swift::SILFunctionTypeRepresentation::ObjCMethod);
+  static_assert((int)FunctionTypeRepresentation::WitnessMethod == (int)swift::SILFunctionTypeRepresentation::WitnessMethod);
+  static_assert((int)FunctionTypeRepresentation::Closure == (int)swift::SILFunctionTypeRepresentation::Closure);
+  static_assert((int)FunctionTypeRepresentation::CXXMethod == (int)swift::SILFunctionTypeRepresentation::CXXMethod);
+  static_assert((int)FunctionTypeRepresentation::KeyPathAccessorGetter == (int)swift::SILFunctionTypeRepresentation::KeyPathAccessorGetter);
+  static_assert((int)FunctionTypeRepresentation::KeyPathAccessorSetter == (int)swift::SILFunctionTypeRepresentation::KeyPathAccessorSetter);
+  static_assert((int)FunctionTypeRepresentation::KeyPathAccessorEquals == (int)swift::SILFunctionTypeRepresentation::KeyPathAccessorEquals);
+  static_assert((int)FunctionTypeRepresentation::KeyPathAccessorHash == (int)swift::SILFunctionTypeRepresentation::KeyPathAccessorHash);
+
+  auto fnType = unbridged()->castTo<swift::SILFunctionType>();
+  return (FunctionTypeRepresentation)(fnType->getRepresentation());
+}
+
 BridgedASTType BridgedASTType::subst(BridgedSubstitutionMap substMap) const {
   return {unbridged().subst(substMap.unbridged()).getPointer()};
 }