FS0073: internal error: Undefined or unsolved type variable when using records with generic type variables and overloaded operators in inline function

[idars]

When defining a set of generic Vector types, I came across this error after adding an inline function that internally uses an overloaded operator (e.g. op_Addition as in the example below) that take a vector and a constant ('T).

Repro steps

1. Run the following code in Visual Studio (F# Interactive):

type Vector<'T> =
    { X: 'T
      Y: 'T }
    static member inline (+) (u, a) =
        { X = u.X + a
          Y = u.Y + a }

module Vector =
    let inline add (vector: Vector<'T>) amount =
        vector + amount

Expected behavior

Should presumably not throw an internal error.

Actual behavior

F# encounters an internal error:

> error FS0073: internal error: Undefined or unsolved type variable: ^_?16934

Known workarounds

Any of the following steps prevent the internal error from occurring:

• Avoiding the overloaded operator
• Using a unary operator instead of a binary operator
• Removing the inline function
• Constraining the type variable of amount
• Not using a generic type variable for Vector

Related information

• Operating system - Windows 10
• F# 4.7.2
• .NET Runtime kind - .NET Core 3.1
• Editing Tools - Visual Studio 2019 16.5.3

Possibly related issue: #6648

[cartermp]

Worth noting that a console app targeting .NET Core does not exhibit this:

[cartermp]

Confirmed with dotnet fsi as well - there's some weird inconsistency with FSI and compiling as an app going on here

[gusty]

@cartermp I can confirm that the fix @dsyme did while testing F#+ for FS-1043 solves this issue.

Running the sample from an fsi compiled with the feature/ext branch without the language switch compiles fine:

Microsoft (R) F# Interactive version 10.10.0.0 for F# 4.7
Copyright (c) Microsoft Corporation. All Rights Reserved.

For help type #help;;

>
- type Vector<'T> =
-     { X: 'T
-       Y: 'T }
-     static member inline (+) (u, a) =
-         { X = u.X + a
-           Y = u.Y + a }
-
- module Vector =
-     let inline add (vector: Vector<'T>) amount =
-         vector + amount
- ;;
type Vector<'T> =
  { X: 'T
    Y: 'T }
  with
    static member
      ( + ) : u:Vector< ^a> * a: ^b -> Vector< ^c>
                when ( ^a or  ^b) : (static member ( + ) :  ^a *  ^b ->  ^c)
  end
module Vector = begin
  val inline add :
    vector:Vector<'T> -> amount: ^a ->  ^b
      when (Vector<'T> or  ^a) : (static member ( + ) : Vector<'T> *  ^a ->
                                                           ^b)
end

Here's the fix #6805 (comment) I mean, the commits before my comment.

[dsyme]

I've recorded this in #9416 to investiaget in the context of that branch work