fix: Remove deprecated lang constructs

Author: lynzrand

encoding/decoding_test.mbt

@@ -758,7 +758,7 @@ test "lossy decoding UTF16BE which is `HI+!LO`" {
 }
 
 ///|
-test "decode_lossy_to/UTF16BE" {
+test "decode_lossy_to/UTF16BE_2" {
   let src = b"\xD8\x00\x00\x48"
   assert_eq(src, b"\xd8\x00\x00\x48")
   let decoder = @encoding.decoder(UTF16BE)

rational/pkg.generated.mbti

@@ -26,21 +26,21 @@ impl ToJson for RationalError
 
 // Types and methods
 type Rational[T]
+#as_free_fn
 fn[T : Integral] Rational::abs(Self[T]) -> Self[T]
-fnalias Rational::abs
 fn[T : Integral] Rational::add(Self[T], Self[T]) -> Self[T] // from trait `Add`
 fn[T : Integral] Rational::arbitrary(Int, @splitmix.RandomState) -> Self[T] // from trait `@quickcheck.Arbitrary`
+#as_free_fn
 fn[T : Integral] Rational::ceil(Self[T]) -> T
-fnalias Rational::ceil
 fn[T : Integral] Rational::compare(Self[T], Self[T]) -> Int // from trait `Compare`
 fn[T : Integral] Rational::div(Self[T], Self[T]) -> Self[T] // from trait `Div`
 fn[T : Eq] Rational::equal(Self[T], Self[T]) -> Bool // from trait `Eq`
+#as_free_fn
 fn[T : Integral] Rational::floor(Self[T]) -> T
-fnalias Rational::floor
+#as_free_fn
 fn[T : Integral] Rational::fract(Self[T]) -> Self[T]
-fnalias Rational::fract
+#as_free_fn
 fn[T : Integral] Rational::is_integer(Self[T]) -> Bool
-fnalias Rational::is_integer
 fn[T : Integral] Rational::mul(Self[T], Self[T]) -> Self[T] // from trait `Mul`
 fn[T : Integral] Rational::neg(Self[T]) -> Self[T] // from trait `Neg`
 #deprecated
@@ -56,13 +56,13 @@ fn[T : Integral] Rational::op_neg(Self[T]) -> Self[T] // from trait `Neg`
 #deprecated
 fn[T : Integral] Rational::op_sub(Self[T], Self[T]) -> Self[T] // from trait `Sub`
 fn[T : Integral] Rational::output(Self[T], &Logger) -> Unit // from trait `Show`
+#as_free_fn
 fn[T : Integral] Rational::reciprocal(Self[T]) -> Self[T]
-fnalias Rational::reciprocal
 fn[T : Integral] Rational::sub(Self[T], Self[T]) -> Self[T] // from trait `Sub`
 fn Rational::to_double(Self[Int64]) -> Double
 fn[T : Integral] Rational::to_string(Self[T]) -> String // from trait `Show`
+#as_free_fn
 fn[T : Integral] Rational::trunc(Self[T]) -> T
-fnalias Rational::trunc
 impl[T : Integral] Add for Rational[T]
 impl[T : Integral] Compare for Rational[T]
 impl[T : Integral] Div for Rational[T]

rational/rational.mbt

@@ -210,6 +210,7 @@ pub impl[T : Integral] Div for Rational[T] with div(self, other) {
 /// inspect(negative_three, content="-3")
 /// ```
 ///
+#as_free_fn
 pub fn[T : Integral] Rational::reciprocal(self : Rational[T]) -> Rational[T] {
   if self.numerator.signum() < 0 {
     new_unchecked(-self.denominator, -self.numerator)
@@ -263,6 +264,7 @@ pub impl[T : Integral] Neg for Rational[T] with neg(self : Rational[T]) -> Ratio
 /// inspect(negative.abs(), content="3/4")
 /// ```
 ///
+#as_free_fn
 pub fn[T : Integral] Rational::abs(self : Rational[T]) -> Rational[T] {
   new_unchecked(self.numerator.abs(), self.denominator)
 }
@@ -514,6 +516,7 @@ pub fn from_double(value : Double) -> Rational64 raise RationalError {
 /// inspect(r3.ceil(), content="2")
 /// ```
 ///
+#as_free_fn
 pub fn[T : Integral] Rational::ceil(self : Rational[T]) -> T {
   let sign = if self.numerator.signum() < 0 {
     T::from_int(-1)
@@ -551,6 +554,7 @@ pub fn[T : Integral] Rational::ceil(self : Rational[T]) -> T {
 /// inspect(r3.floor(), content="2")
 /// ```
 ///
+#as_free_fn
 pub fn[T : Integral] Rational::floor(self : Rational[T]) -> T {
   let sign = if self.numerator.signum() < 0 {
     T::from_int(-1)
@@ -590,6 +594,7 @@ pub fn[T : Integral] Rational::floor(self : Rational[T]) -> T {
 /// inspect(d.trunc(), content="-2")
 /// ```
 ///
+#as_free_fn
 pub fn[T : Integral] Rational::trunc(self : Rational[T]) -> T {
   if self.numerator.signum() < 0 {
     -(-self.numerator / self.denominator)
@@ -622,6 +627,7 @@ pub fn[T : Integral] Rational::trunc(self : Rational[T]) -> T {
 /// inspect(r3.fract(), content="0")        // fractional part is 0
 /// ```
 ///
+#as_free_fn
 pub fn[T : Integral] Rational::fract(self : Rational[T]) -> Rational[T] {
   new_unchecked(self.numerator % self.denominator, self.denominator)
 }
@@ -709,12 +715,12 @@ pub impl[T : Integral] @quickcheck.Arbitrary for Rational[T] with arbitrary(
 /// inspect(zero.is_integer(), content="true")
 /// ```
 ///
+#as_free_fn
 pub fn[T : Integral] Rational::is_integer(self : Rational[T]) -> Bool {
   self.denominator == T::from_int(1)
 }
 
 ///|
-pub fnalias Rational::(abs, ceil, floor, trunc, is_integer, fract, reciprocal)
 
 ///|
 test "op_add" {

stack/pkg.generated.mbti

@@ -26,10 +26,10 @@ fn[T] Stack::from_stack(Self[T]) -> Self[T]
 fn[T] Stack::is_empty(Self[T]) -> Bool
 fn[T] Stack::iter(Self[T]) -> Iter[T]
 fn[T] Stack::length(Self[T]) -> Int
+#as_free_fn
 fn[T] Stack::new() -> Self[T]
-fnalias Stack::new
+#as_free_fn
 fn[T] Stack::of(FixedArray[T]) -> Self[T]
-fnalias Stack::of
 fn[T : Eq] Stack::op_equal(Self[T], Self[T]) -> Bool
 fn[T : Show] Stack::output(Self[T], &Logger) -> Unit // from trait `Show`
 fn[T] Stack::peek(Self[T]) -> T?

stack/stack.mbt

@@ -12,17 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-///|
-/// Create an empty stack.
-///
-/// # Example
-///
-/// ```
-/// let s : Stack[Int] = @stack.new()
-/// assert_true(s.is_empty())
-/// ```
-pub fnalias Stack::new
-
 ///|
 /// Create an empty stack.
 ///
@@ -31,7 +20,10 @@ pub fnalias Stack::new
 /// ```
 /// let s : Stack[Int] = @stack.Stack::new()
 /// assert_true(s.is_empty())
+/// let s1 : Stack[Int] = @stack.new()
+/// assert_true(s.is_empty())
 /// ```
+#as_free_fn
 pub fn[T] Stack::new() -> Stack[T] {
   { elements: @list.from_array([]), len: 0 }
 }
@@ -85,13 +77,11 @@ test "from_iter" {
 /// let s = of([1, 2, 3])
 /// assert_eq(s.length(), 3)
 /// ```
+#as_free_fn
 pub fn[T] Stack::of(array : FixedArray[T]) -> Stack[T] {
   { elements: @list.of(array), len: array.length() }
 }
 
-///|
-pub fnalias Stack::of
-
 ///|
 test "of" {
   let s = of([1, 2, 3])