tests/language/nonfunction_type_aliases/private_names/private_name_library.dart

// Copyright (c) 2021, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

// Shared code for tests that private names exported publicly via a typedef work
// as expected.

library private;

// Sentinel values for checking that the correct methods are called.  Methods
// defined in this library return the private sentinel, and (potentially
// overriding) methods defined in other libraries return the public sentinel.
// By checking the return value of methods against the respective sentinels,
// test expectations can establish whether the correct method has been called.
const int privateLibrarySentinel = -1;
const int publicLibrarySentinel = privateLibrarySentinel + 1;

// A private class that will be exported via a public typedef.
class _PrivateClass {
  final int x;
  const _PrivateClass() : x = privateLibrarySentinel;
  _PrivateClass.named(this.x);
  static int staticMethod() => privateLibrarySentinel;
  static int _privateStaticMethod() => privateLibrarySentinel;
  int instanceMethod() => privateLibrarySentinel;
  int _privateInstanceMethod() => privateLibrarySentinel;
}

// Export the private class publicly, along with a factory.
typedef PublicClass = _PrivateClass;
PublicClass mkPublicClass() => PublicClass();

// Export the private class publicly via an indirection through another private
// typedef, along with a factory.
typedef _PrivateTypeDef = _PrivateClass;
typedef AlsoPublicClass = _PrivateTypeDef;
AlsoPublicClass mkAlsoPublicClass() => AlsoPublicClass();

// A private generic class which will be exported through a public typedef.
class _PrivateGenericClass<T> {
  static int staticMethod() => privateLibrarySentinel;
}

// Export the private generic class publicly, along with a factory and a
// specific instantiation.
typedef PublicGenericClass<T> = _PrivateGenericClass<T>;
PublicGenericClass<T> mkPublicGenericClass<T>() => PublicGenericClass();
typedef PublicGenericClassOfInt = _PrivateGenericClass<int>;

// Helper methods to do virtual calls on instances of _PrivateClass in this
// library context.
int callPrivateInstanceMethod(_PrivateClass other) => other._privateInstanceMethod();
int callInstanceMethod(_PrivateClass other) => other.instanceMethod();
int readInstanceField(_PrivateClass other) => other.x;

// A private mixin to be exported via a typedef.
mixin _PrivateMixin {
  int mixinMethod() => privateLibrarySentinel;
  int _privateMixinMethod() => privateLibrarySentinel;
}

// Helper method to call a private method on the mixin in this library context.
int callPrivateMixinMethod(_PrivateMixin other) => other._privateMixinMethod();

// Export the private mixin
typedef PublicMixin = _PrivateMixin;

// A private super-mixin which is intended to be mixed onto PublicClass
// and which makes super calls into it.
mixin _PrivateSuperMixin on PublicClass {
  int mixinMethod() => super.instanceMethod();
  int _privateMixinMethod() => super._privateInstanceMethod();
}

// Call the private SuperMixinMethod
int callPrivateSuperMixinMethod(_PrivateSuperMixin other) =>
other._privateMixinMethod();

// Export the private super-mixin.
typedef PublicSuperMixin = _PrivateSuperMixin;