[AutoDiff] Mangle @differentiable function types.

[dan-zheng]

• Mangle @differentiable and @differentiable(linear) function types,
  both escaping and non-escaping variants.
• Update TargetFunctionTypeFlags to represent linear functions.
• Add TypeDecoder tests.

[dan-zheng]

I tried using a single DifferentiabilityMask, similar to the one in AnyFunctionType::ExtInfo:

      DifferentiabilityMask  = 0xF8000000U,
      DifferentiabilityShift = 24U

But I didn't figure out how to make it work all the way. Things are tricky because the mask is F8 instead of FF, which requires extra bitshifting.

[rxwei]

How would you differentiate between @differentiable @convention(thin) and @differentiable?

[dan-zheng]

Good point. Currently, modifiers like @convention(thin) and @differentiable have their own function type demangle node variant:

Modifier	Demangle node kind
-	NoEscapeFunctionType
@escaping	FunctionType (escaping)
@autoclosure	AutoClosureType
@escaping @autoclosure	EscapingAutoClosureType
...	...

Here's what it looks like:

$ $SWIFT_BIN/swift-demangle --expand sS2fXfD
Demangling for $sS2fXfD
kind=Global
  kind=TypeMangling
    kind=Type
      kind=ThinFunctionType
        kind=ArgumentTuple
          kind=Type
            kind=Structure
              kind=Module, text="Swift"
              kind=Identifier, text="Float"
        kind=ReturnType
          kind=Type
            kind=Structure
              kind=Module, text="Swift"
              kind=Identifier, text="Float"
$sS2fXfD ---> @convention(thin) (Swift.Float) -> Swift.Float

This leads to an explosion of demangle node kinds for combinations of modifiers.

A more reflexible representation would be to have a single FunctionType demangle node kind, with modifier nodes as children in a list. Dummy view:

      kind=FunctionType
        kind=FunctionTypeModifiers
          kind=ThinFunction
          kind=EscapingFunction
          kind=DifferentiableFunction
        kind=ArgumentTuple
          kind=Type
            kind=Structure
              kind=Module, text="Swift"
              kind=Identifier, text="Float"
        kind=ReturnType
          kind=Type
            kind=Structure
              kind=Module, text="Swift"
              kind=Identifier, text="Float"

Changing the mangling scheme certainly seems breaking though. The significance of type mangling isn't exactly clear to me: I imagine LLDB uses this mangling to show types of variables. Perhaps it's not important to capture all combinations of function type modifiers, only the semantically important ones (@differentiable is probably more semantically heavy than @escaping).

Started a discussion at https://forums.swift.org/t/questions-about-function-type-mangling/26360.

[dan-zheng]

@swift-ci Please clean test tensorflow

[dan-zheng]

@swift-ci Please test tensorflow