Different tear-offs are wrongly identical in analyzer

[sgrekhov]

Consider the following code

class CheckIdentical {
  const CheckIdentical(Object? o1, Object? o2) : assert(identical(o1, o2));
}

typedef MyList<T extends num> = List<T>;

main() {
  const v1 = MyList<int>.filled;
  const v2 = MyList<int>.filled;
  const v3 = (MyList.filled)<int>;

  const CheckIdentical(v1, v2);
  const CheckIdentical(v1, v3); // Error in VM here (Error: Constant evaluation error), no issues in analyzer
}

According to @eernstg MyList is not a proper rename, so if we tear off a generic function then it gets the identity for MyList, and it's never identical to any tearoff of a List constructor.

However, when we pass actual type arguments in the tearoff, we get the fully expanded type alias (whether or not it's a proper rename, that doesn't matter). That is, MyList<int>.filled is identical to List<int>.filled.

So we should expect that v1 and v2 are identical, but v1 and v3 are not identical, so there's an issue for the analyzer.

[eernstg]

Perhaps the issue would be a bit easier to read if the code is changed to have const CheckNotIdentical(v1, v3), such that the program succeeds with a tool that behaves as specified.