library /*isNonNullableByDefault*/;
import self as self;
import "main_lib.dart" as mai;
import "dart:core" as core;

import "org-dartlang-testcase:///main_lib.dart";

abstract class RenderAnimatedOpacityMixin<T extends mai::RenderObject> extends mai::RenderObjectWithChildMixin<self::RenderAnimatedOpacityMixin::T> /*isMixinDeclaration*/  {
}
abstract class _RenderAnimatedOpacity&RenderProxyBox&RenderProxyBoxMixin extends mai::RenderProxyBox implements mai::RenderProxyBoxMixin<mai::RenderBox> /*isAnonymousMixin,isEliminatedMixin*/  {
  synthetic constructor •() → self::_RenderAnimatedOpacity&RenderProxyBox&RenderProxyBoxMixin
    : super mai::RenderProxyBox::•()
    ;
  @#C1
  method /* from org-dartlang-testcase:///main_lib.dart */ hitTestChildren(mai::BoxHitTestResult result, {required mai::Offset position = #C2}) → core::bool {
    return let final core::bool? #t1 = let final mai::RenderBox? #t2 = this.{mai::RenderObjectWithChildMixin::child} in #t2.{core::Object::==}(null) ?{core::bool?} null : #t2{mai::RenderBox}.{mai::RenderBox::hitTest}(result, position: position) in #t1.{core::Object::==}(null) ?{core::bool} false : #t1{core::bool};
  }
}
abstract class _RenderAnimatedOpacity&RenderProxyBox&RenderProxyBoxMixin&RenderAnimatedOpacityMixin extends self::_RenderAnimatedOpacity&RenderProxyBox&RenderProxyBoxMixin implements self::RenderAnimatedOpacityMixin<mai::RenderBox> /*isAnonymousMixin,isEliminatedMixin*/  {
  synthetic constructor •() → self::_RenderAnimatedOpacity&RenderProxyBox&RenderProxyBoxMixin&RenderAnimatedOpacityMixin
    : super self::_RenderAnimatedOpacity&RenderProxyBox&RenderProxyBoxMixin::•()
    ;
}
class RenderAnimatedOpacity extends self::_RenderAnimatedOpacity&RenderProxyBox&RenderProxyBoxMixin&RenderAnimatedOpacityMixin {
  synthetic constructor •() → self::RenderAnimatedOpacity
    : super self::_RenderAnimatedOpacity&RenderProxyBox&RenderProxyBoxMixin&RenderAnimatedOpacityMixin::•()
    ;
}
static method main() → dynamic {
  new self::RenderAnimatedOpacity::•();
}

library /*isNonNullableByDefault*/;
import self as mai;
import "dart:core" as core;

class Offset extends core::Object {
  synthetic constructor •() → mai::Offset
    : super core::Object::•()
    ;
}
class AbstractNode extends core::Object {
  synthetic constructor •() → mai::AbstractNode
    : super core::Object::•()
    ;
}
abstract class DiagnosticableTreeMixin extends core::Object /*isMixinDeclaration*/  {
}
abstract class HitTestTarget extends core::Object {
  synthetic constructor •() → mai::HitTestTarget
    : super core::Object::•()
    ;
}
class HitTestResult extends core::Object {
  synthetic constructor •() → mai::HitTestResult
    : super core::Object::•()
    ;
}
class BoxHitTestResult extends mai::HitTestResult {
  synthetic constructor •() → mai::BoxHitTestResult
    : super mai::HitTestResult::•()
    ;
}
abstract class _RenderObject&AbstractNode&DiagnosticableTreeMixin extends mai::AbstractNode implements mai::DiagnosticableTreeMixin /*isAnonymousMixin,isEliminatedMixin*/  {
  synthetic constructor •() → mai::_RenderObject&AbstractNode&DiagnosticableTreeMixin
    : super mai::AbstractNode::•()
    ;
}
abstract class RenderObject extends mai::_RenderObject&AbstractNode&DiagnosticableTreeMixin implements mai::HitTestTarget {
  synthetic constructor •() → mai::RenderObject
    : super mai::_RenderObject&AbstractNode&DiagnosticableTreeMixin::•()
    ;
}
abstract class RenderBox extends mai::RenderObject {
  synthetic constructor •() → mai::RenderBox
    : super mai::RenderObject::•()
    ;
  method hitTest(mai::BoxHitTestResult result, {required mai::Offset position = #C2}) → core::bool
    return false;
  method hitTestChildren(mai::BoxHitTestResult result, {required mai::Offset position = #C2}) → core::bool
    return false;
}
abstract class RenderObjectWithChildMixin<ChildType extends mai::RenderObject> extends mai::RenderObject /*isMixinDeclaration*/  {
  generic-covariant-impl field mai::RenderObjectWithChildMixin::ChildType? _child = null;
  get child() → mai::RenderObjectWithChildMixin::ChildType?
    return this.{mai::RenderObjectWithChildMixin::_child};
}
abstract class _RenderProxyBoxMixin&RenderBox&RenderObjectWithChildMixin<T extends mai::RenderBox> extends core::Object implements mai::RenderBox, mai::RenderObjectWithChildMixin<mai::_RenderProxyBoxMixin&RenderBox&RenderObjectWithChildMixin::T> /*isAnonymousMixin*/  {
  synthetic constructor •() → mai::_RenderProxyBoxMixin&RenderBox&RenderObjectWithChildMixin<mai::_RenderProxyBoxMixin&RenderBox&RenderObjectWithChildMixin::T>
    : super core::Object::•()
    ;
}
abstract class RenderProxyBoxMixin<T extends mai::RenderBox> extends mai::_RenderProxyBoxMixin&RenderBox&RenderObjectWithChildMixin<mai::RenderProxyBoxMixin::T> /*isMixinDeclaration*/  {
  @#C1
  method hitTestChildren(mai::BoxHitTestResult result, {required mai::Offset position = #C2}) → core::bool {
    return let final core::bool? #t3 = let final mai::RenderProxyBoxMixin::T? #t4 = this.{mai::RenderObjectWithChildMixin::child} in #t4.{core::Object::==}(null) ?{core::bool?} null : #t4{mai::RenderProxyBoxMixin::T}.{mai::RenderBox::hitTest}(result, position: position) in #t3.{core::Object::==}(null) ?{core::bool} false : #t3{core::bool};
  }
}
abstract class _RenderProxyBox&RenderBox&RenderObjectWithChildMixin extends mai::RenderBox implements mai::RenderObjectWithChildMixin<mai::RenderBox> /*isAnonymousMixin,isEliminatedMixin*/  {
  generic-covariant-impl field mai::RenderBox? _child = null;
  synthetic constructor •() → mai::_RenderProxyBox&RenderBox&RenderObjectWithChildMixin
    : super mai::RenderBox::•()
    ;
  get child() → mai::RenderBox?
    return this.{mai::RenderObjectWithChildMixin::_child};
}
abstract class _RenderProxyBox&RenderBox&RenderObjectWithChildMixin&RenderProxyBoxMixin extends mai::_RenderProxyBox&RenderBox&RenderObjectWithChildMixin implements mai::RenderProxyBoxMixin<mai::RenderBox> /*isAnonymousMixin,isEliminatedMixin*/  {
  synthetic constructor •() → mai::_RenderProxyBox&RenderBox&RenderObjectWithChildMixin&RenderProxyBoxMixin
    : super mai::_RenderProxyBox&RenderBox&RenderObjectWithChildMixin::•()
    ;
  @#C1
  method hitTestChildren(mai::BoxHitTestResult result, {required mai::Offset position = #C2}) → core::bool {
    return let final core::bool? #t5 = let final mai::RenderBox? #t6 = this.{mai::RenderObjectWithChildMixin::child} in #t6.{core::Object::==}(null) ?{core::bool?} null : #t6{mai::RenderBox}.{mai::RenderBox::hitTest}(result, position: position) in #t5.{core::Object::==}(null) ?{core::bool} false : #t5{core::bool};
  }
}
class RenderProxyBox extends mai::_RenderProxyBox&RenderBox&RenderObjectWithChildMixin&RenderProxyBoxMixin {
  synthetic constructor •() → mai::RenderProxyBox
    : super mai::_RenderProxyBox&RenderBox&RenderObjectWithChildMixin&RenderProxyBoxMixin::•()
    ;
}

constants  {
  #C1 = core::_Override {}
  #C2 = null
}