// Scala source: Namers.scala
package scala.tools.nsc {
  package typechecker {
    abstract trait Namers extends java.lang.Object with ScalaObject { self: scala.tools.nsc.typechecker.Analyzer => 
      /*accessor*/ def scala$tools$nsc$typechecker$Namers$_setter_$caseClassOfModuleClass_=(x$1: scala.collection.mutable.HashMap): Unit;
      /*accessor*/ def scala$tools$nsc$typechecker$Namers$_setter_$classAndNamerOfModule_=(x$1: scala.collection.mutable.HashMap): Unit;
      def newNamer(context: scala.tools.nsc.typechecker.Context): scala.tools.nsc.typechecker.Namer;
      /*stable*/ /*accessor*/ private[typechecker] def caseClassOfModuleClass(): scala.collection.mutable.HashMap;
      /*stable*/ /*accessor*/ private[typechecker] def classAndNamerOfModule(): scala.collection.mutable.HashMap;
      def resetNamer(): Unit;
      def mkTypeCompleter(t: scala.tools.nsc.ast.Tree, c: Function1): scala.tools.nsc.typechecker.TypeCompleter;
      def underlying(member: scala.tools.nsc.symtab.Symbol): scala.tools.nsc.symtab.Symbol;
      def varNotice(sym: scala.tools.nsc.symtab.Symbol): java.lang.String
    };
    abstract trait Namers$class extends  { self: scala.tools.nsc.typechecker.Analyzer => 
      def newNamer($this: scala.tools.nsc.typechecker.Analyzer, context: scala.tools.nsc.typechecker.Context): scala.tools.nsc.typechecker.Namer = new scala.tools.nsc.typechecker.NormalNamer($this, context);
      def resetNamer($this: scala.tools.nsc.typechecker.Analyzer): Unit = {
        $this.caseClassOfModuleClass().clear();
        $this.classAndNamerOfModule().clear()
      };
      def mkTypeCompleter($this: scala.tools.nsc.typechecker.Analyzer, t$1: scala.tools.nsc.ast.Tree, c$1: Function1): scala.tools.nsc.typechecker.TypeCompleter = new /*anonymous class*/ $anon$1($this, t$1, c$1);
      def underlying($this: scala.tools.nsc.typechecker.Analyzer, member: scala.tools.nsc.symtab.Symbol): scala.tools.nsc.symtab.Symbol = if (member.hasFlag(134217728L))
        if (member.isDeferred())
          {
            val getter: scala.tools.nsc.symtab.Symbol = if (member.isSetter())
              member.getter(member.owner())
            else
              member;
            val result: scala.tools.nsc.symtab.TermSymbol = getter.owner().newValue(getter.pos(), getter.name()).setInfo(getter.tpe().resultType()).setFlag(16L).$asInstanceOf[scala.tools.nsc.symtab.TermSymbol]();
            if (getter.setter(member.owner()).!=($this.global().NoSymbol()))
              result.setFlag(4096L)
            else
              scala.runtime.BoxedUnit.UNIT;
            result
          }
        else
          member.accessed()
      else
        member;
      def varNotice($this: scala.tools.nsc.typechecker.Analyzer, sym: scala.tools.nsc.symtab.Symbol): java.lang.String = if ($this.underlying(sym).isVariable())
        "\012(Note that variables need to be initialized to be defined)"
      else
        "";
      def /*Namers$class*/$init$($this: scala.tools.nsc.typechecker.Analyzer): Unit = {
        $this.scala$tools$nsc$typechecker$Namers$_setter_$caseClassOfModuleClass_=(new scala.collection.mutable.HashMap());
        $this.scala$tools$nsc$typechecker$Namers$_setter_$classAndNamerOfModule_=(new scala.collection.mutable.HashMap());
        ()
      }
    };
    class DeSkolemizeMap extends scala.tools.nsc.symtab.TypeMap with ScalaObject {
      /*paramaccessor*/ private[this] val tparams: List = _;
      def apply(tp: scala.tools.nsc.symtab.Type): scala.tools.nsc.symtab.Type = {
        var temp1: scala.tools.nsc.symtab.Type = tp;
        if (temp1.$isInstanceOf[scala.tools.nsc.symtab.TypeRef]())
          {
            var temp2: scala.tools.nsc.symtab.TypeRef = temp1.$asInstanceOf[scala.tools.nsc.symtab.TypeRef]();
            var temp3: scala.tools.nsc.symtab.Type = temp2.pre();
            {
              var temp4: scala.tools.nsc.symtab.Symbol = temp2.sym();
              val temp5: List = temp2.args();
              {
                val args: List = temp5;
                val sym: scala.tools.nsc.symtab.Symbol = temp4;
                {
                  val pre: scala.tools.nsc.symtab.Type = temp3;
                  if (DeSkolemizeMap.this.gd1$1(pre, sym, args))
                    {
                      val pre: scala.tools.nsc.symtab.Type = temp3;
                      val sym: scala.tools.nsc.symtab.Symbol = temp4;
                      {
                        val args: List = temp5;
                        // @todo check -- LabelDef 
                        body_0: 
                        /*(pre,sym,args)*/{
                          DeSkolemizeMap.this.mapOver(DeSkolemizeMap.this.scala$tools$nsc$typechecker$Namers$DeSkolemizeMap$$$outer().global().rawTypeRef(DeSkolemizeMap.this.scala$tools$nsc$typechecker$Namers$DeSkolemizeMap$$$outer().global().NoPrefix(), sym.deSkolemize(), args))
                        }
                      };
                      /*EmptyTree*/
                    }
                  else
                    // @todo check -- LabelDef 
                    body_1: 
                    /*()*/{
                      DeSkolemizeMap.this.mapOver(tp)
                    }
                };
                /*EmptyTree*/
              };
              /*EmptyTree*/
            };
            /*EmptyTree*/
          }
        else
           () // @todo -- goto body_1 /* vargs ()*/
          
      };
      protected /*synthetic*/ /*paramaccessor*/ val $outer: scala.tools.nsc.typechecker.Analyzer = _;
      /*synthetic*/ /*stable*/ def scala$tools$nsc$typechecker$Namers$DeSkolemizeMap$$$outer(): scala.tools.nsc.typechecker.Analyzer = DeSkolemizeMap.this.$outer;
      /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = DeSkolemizeMap.this.apply(v1.$asInstanceOf[scala.tools.nsc.symtab.Type]());
      final /*synthetic*/ private[this] def gd1$1(x$1: scala.tools.nsc.symtab.Type, x$2: scala.tools.nsc.symtab.Symbol, x$3: List): Boolean = x$2.isTypeSkolem().&&(DeSkolemizeMap.this.tparams.contains(x$2.deSkolemize()));
      def this($outer: scala.tools.nsc.typechecker.Analyzer, tparams: List): scala.tools.nsc.typechecker.DeSkolemizeMap = {
        DeSkolemizeMap.this.tparams = tparams;
        if ($outer.eq(null))
          throw new java.lang.NullPointerException()
        else
          DeSkolemizeMap.this.$outer = $outer;
        DeSkolemizeMap.super.this($outer.global());
        ()
      }
    };
    class NormalNamer extends scala.tools.nsc.typechecker.Namer with ScalaObject {
      /*synthetic*/ /*stable*/ def scala$tools$nsc$typechecker$Namers$NormalNamer$$$outer(): scala.tools.nsc.typechecker.Analyzer = NormalNamer.this.$outer;
      def this($outer: scala.tools.nsc.typechecker.Analyzer, context: scala.tools.nsc.typechecker.Context): scala.tools.nsc.typechecker.NormalNamer = {
        NormalNamer.super.this($outer, context);
        ()
      }
    };
    @SerialVersionUID(0) @serializable 
    final /*synthetic*/ class $anonfun$primaryConstructorParamNamer$1$1 extends scala.runtime.AbstractFunction1 {
      final def apply(sym: scala.tools.nsc.symtab.Symbol): scala.tools.nsc.symtab.Symbol = $anonfun$primaryConstructorParamNamer$1$1.this.paramContext$1.scope().enter(sym);
      final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = $anonfun$primaryConstructorParamNamer$1$1.this.apply(v1.$asInstanceOf[scala.tools.nsc.symtab.Symbol]());
      /*synthetic*/ /*paramaccessor*/ private[this] val paramContext$1: scala.tools.nsc.typechecker.Context = _;
      def this($outer: scala.tools.nsc.typechecker.Namer, paramContext$1: scala.tools.nsc.typechecker.Context): /*anonymous class*/ $anonfun$primaryConstructorParamNamer$1$1 = {
        $anonfun$primaryConstructorParamNamer$1$1.this.paramContext$1 = paramContext$1;
        $anonfun$primaryConstructorParamNamer$1$1.super.this();
        ()
      }
    };
    @SerialVersionUID(0) @serializable 
    final /*synthetic*/ class $anonfun$enterSyms$1 extends scala.runtime.AbstractFunction1 {
      final def apply(tree: scala.tools.nsc.ast.Tree): Unit = {
        val txt: scala.tools.nsc.typechecker.Context = $anonfun$enterSyms$1.this.namer$1.elem.$asInstanceOf[scala.tools.nsc.typechecker.Namer]().enterSym(tree);
        if (txt.eq($anonfun$enterSyms$1.this.namer$1.elem.$asInstanceOf[scala.tools.nsc.typechecker.Namer]().context()).unary_!())
          $anonfun$enterSyms$1.this.namer$1.elem = $anonfun$enterSyms$1.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$$outer().newNamer(txt)
        else
          ()
      };
      /*synthetic*/ /*paramaccessor*/ private[this] val $outer: scala.tools.nsc.typechecker.Namer = _;
      final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = {
        $anonfun$enterSyms$1.this.apply(v1.$asInstanceOf[scala.tools.nsc.ast.Tree]());
        scala.runtime.BoxedUnit.UNIT
      };
      /*synthetic*/ /*paramaccessor*/ private[this] val namer$1: scala.runtime.ObjectRef = _;
      def this($outer: scala.tools.nsc.typechecker.Namer, namer$1: scala.runtime.ObjectRef): /*anonymous class*/ $anonfun$enterSyms$1 = {
        if ($outer.eq(null))
          throw new java.lang.NullPointerException()
        else
          $anonfun$enterSyms$1.this.$outer = $outer;
        $anonfun$enterSyms$1.this.namer$1 = namer$1;
        $anonfun$enterSyms$1.super.this();
        ()
      }
    };
    @SerialVersionUID(0) @serializable 
    final /*synthetic*/ class $anonfun$1 extends scala.runtime.AbstractFunction1 {
      final def apply(x$1: scala.tools.nsc.symtab.Symbol): scala.tools.nsc.symtab.Symbol = x$1.newTypeSkolem();
      final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = $anonfun$1.this.apply(v1.$asInstanceOf[scala.tools.nsc.symtab.Symbol]());
      def this($outer: scala.tools.nsc.typechecker.Namer): /*anonymous class*/ $anonfun$1 = {
        $anonfun$1.super.this();
        ()
      }
    };
    final class $anon$3 extends scala.tools.nsc.symtab.LazyType {
      override def complete(sym: scala.tools.nsc.symtab.Symbol): Unit = {
        sym.setInfo(sym.deSkolemize().info().substSym($anon$3.this.tparams$1, $anon$3.this.tskolems$1));
        ()
      };
      /*synthetic*/ /*paramaccessor*/ private[this] val tparams$1: List = _;
      /*synthetic*/ /*paramaccessor*/ private[this] val tskolems$1: List = _;
      def this($outer: scala.tools.nsc.typechecker.Namer, tparams$1: List, tskolems$1: List): /*anonymous class*/ $anon$3 = {
        $anon$3.this.tparams$1 = tparams$1;
        $anon$3.this.tskolems$1 = tskolems$1;
        $anon$3.super.this($outer.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global());
        ()
      }
    };
    @SerialVersionUID(0) @serializable 
    final /*synthetic*/ class $anonfun$newTypeSkolems$1 extends scala.runtime.AbstractFunction1 {
      final def apply(x$2: scala.tools.nsc.symtab.Symbol): scala.tools.nsc.symtab.Symbol = x$2.setInfo($anonfun$newTypeSkolems$1.this.ltp$1);
      final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = $anonfun$newTypeSkolems$1.this.apply(v1.$asInstanceOf[scala.tools.nsc.symtab.Symbol]());
      /*synthetic*/ /*paramaccessor*/ private[this] val ltp$1: scala.tools.nsc.symtab.LazyType = _;
      def this($outer: scala.tools.nsc.typechecker.Namer, ltp$1: scala.tools.nsc.symtab.LazyType): /*anonymous class*/ $anonfun$newTypeSkolems$1 = {
        $anonfun$newTypeSkolems$1.this.ltp$1 = ltp$1;
        $anonfun$newTypeSkolems$1.super.this();
        ()
      }
    };
    @SerialVersionUID(0) @serializable 
    final /*synthetic*/ class $anonfun$2 extends scala.runtime.AbstractFunction1 {
      final def apply(x$3: scala.tools.nsc.ast.TypeDef): scala.tools.nsc.symtab.Symbol = x$3.symbol();
      final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = $anonfun$2.this.apply(v1.$asInstanceOf[scala.tools.nsc.ast.TypeDef]());
      def this($outer: scala.tools.nsc.typechecker.Namer): /*anonymous class*/ $anonfun$2 = {
        $anonfun$2.super.this();
        ()
      }
    };
    @SerialVersionUID(0) @serializable 
    final /*synthetic*/ class $anonfun$skolemize$1 extends scala.runtime.AbstractFunction1 {
      final def apply(x$4: Tuple2): Unit = {
        var temp21: Tuple2 = x$4;
        if (temp21.ne(null))
          {
            var temp22: scala.tools.nsc.ast.TypeDef = temp21._1().$asInstanceOf[scala.tools.nsc.ast.TypeDef]();
            var temp23: scala.tools.nsc.symtab.Symbol = temp21._2().$asInstanceOf[scala.tools.nsc.symtab.Symbol]();
            {
              val tskolem: scala.tools.nsc.symtab.Symbol = temp23;
              val tparam: scala.tools.nsc.ast.TypeDef = temp22;
              {
                val tparam: scala.tools.nsc.ast.TypeDef = temp22;
                val tskolem: scala.tools.nsc.symtab.Symbol = temp23;
                // @todo check -- LabelDef 
                body_0: 
                /*(tparam,tskolem)*/{
                  tparam.symbol_=(tskolem)
                };
                /*EmptyTree*/
              };
              /*EmptyTree*/
            };
            /*EmptyTree*/
          }
        else
          throw new MatchError(temp21.toString())
      };
      final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = {
        $anonfun$skolemize$1.this.apply(v1.$asInstanceOf[Tuple2]());
        scala.runtime.BoxedUnit.UNIT
      };
      def this($outer: scala.tools.nsc.typechecker.Namer): /*anonymous class*/ $anonfun$skolemize$1 = {
        $anonfun$skolemize$1.super.this();
        ()
      }
    };
    @SerialVersionUID(0) @serializable 
    final /*synthetic*/ class $anonfun$3 extends scala.runtime.AbstractFunction1 {
      final def apply(x$6: scala.tools.nsc.symtab.Symbol): Boolean = x$6.isSourceMethod().unary_!();
      final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = scala.Boolean.box($anonfun$3.this.apply(v1.$asInstanceOf[scala.tools.nsc.symtab.Symbol]()));
      def this($outer: scala.tools.nsc.typechecker.Namer): /*anonymous class*/ $anonfun$3 = {
        $anonfun$3.super.this();
        ()
      }
    };
    @SerialVersionUID(0) @serializable 
    final /*synthetic*/ class $anonfun$4 extends scala.runtime.AbstractFunction1 {
      final def apply(x$7: scala.tools.nsc.ast.TypeDef): scala.tools.nsc.symtab.Symbol = x$7.symbol();
      final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = $anonfun$4.this.apply(v1.$asInstanceOf[scala.tools.nsc.ast.TypeDef]());
      def this($outer: /*anonymous class*/ $anonfun$enterSymFinishWith$1): /*anonymous class*/ $anonfun$4 = {
        $anonfun$4.super.this();
        ()
      }
    };
    @SerialVersionUID(0) @serializable 
    final /*synthetic*/ class $anonfun$apply$2 extends scala.runtime.AbstractFunction1 {
      final def apply(x$8: Tuple2): Unit = {
        var temp24: Tuple2 = x$8;
        if (temp24.ne(null))
          {
            var temp25: scala.tools.nsc.ast.ValDef = temp24._1().$asInstanceOf[scala.tools.nsc.ast.ValDef]();
            var temp26: scala.tools.nsc.symtab.Symbol = temp24._2().$asInstanceOf[scala.tools.nsc.symtab.Symbol]();
            {
              val cparam: scala.tools.nsc.symtab.Symbol = temp26;
              val param: scala.tools.nsc.ast.ValDef = temp25;
              {
                val param: scala.tools.nsc.ast.ValDef = temp25;
                val cparam: scala.tools.nsc.symtab.Symbol = temp26;
                // @todo check -- LabelDef 
                body_0: 
                /*(param,cparam)*/{
                  param.tpt().setType($anonfun$apply$2.this.$outer.subst$1.apply(cparam.tpe()));
                  ()
                };
                /*EmptyTree*/
              };
              /*EmptyTree*/
            };
            /*EmptyTree*/
          }
        else
          throw new MatchError(temp24.toString())
      };
      /*synthetic*/ /*paramaccessor*/ private[this] val $outer: /*anonymous class*/ $anonfun$apply$1 = _;
      final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = {
        $anonfun$apply$2.this.apply(v1.$asInstanceOf[Tuple2]());
        scala.runtime.BoxedUnit.UNIT
      };
      def this($outer: /*anonymous class*/ $anonfun$apply$1): /*anonymous class*/ $anonfun$apply$2 = {
        if ($outer.eq(null))
          throw new java.lang.NullPointerException()
        else
          $anonfun$apply$2.this.$outer = $outer;
        $anonfun$apply$2.super.this();
        ()
      }
    };
    @SerialVersionUID(0) @serializable 
    final /*synthetic*/ class $anonfun$apply$1 extends scala.runtime.AbstractFunction1 {
      final def apply(x$9: Tuple2): Unit = {
        var temp27: Tuple2 = x$9;
        if (temp27.ne(null))
          {
            var temp28: List = temp27._1().$asInstanceOf[List]();
            var temp29: List = temp27._2().$asInstanceOf[List]();
            {
              val cparams: List = temp29;
              val params: List = temp28;
              {
                val params: List = temp28;
                val cparams: List = temp29;
                // @todo check -- LabelDef 
                body_0: 
                /*(params,cparams)*/{
                  params.zip(cparams, immutable.this.List.canBuildFrom()).$asInstanceOf[scala.collection.LinearSeqLike]().foreach((new /*anonymous class*/ $anonfun$apply$2($anonfun$apply$1.this): Function1))
                };
                /*EmptyTree*/
              };
              /*EmptyTree*/
            };
            /*EmptyTree*/
          }
        else
          throw new MatchError(temp27.toString())
      };
      final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = {
        $anonfun$apply$1.this.apply(v1.$asInstanceOf[Tuple2]());
        scala.runtime.BoxedUnit.UNIT
      };
      /*synthetic*/ /*paramaccessor*/ val subst$1: scala.tools.nsc.symtab.SubstSymMap = _;
      def this($outer: /*anonymous class*/ $anonfun$enterSymFinishWith$1, subst$1: scala.tools.nsc.symtab.SubstSymMap): /*anonymous class*/ $anonfun$apply$1 = {
        $anonfun$apply$1.this.subst$1 = subst$1;
        $anonfun$apply$1.super.this();
        ()
      }
    };
    @SerialVersionUID(0) @serializable 
    final /*synthetic*/ class $anonfun$enterSymFinishWith$1 extends scala.runtime.AbstractFunction1 {
      final def apply(copySym: scala.tools.nsc.symtab.Symbol): Unit = {
        val constrType: scala.tools.nsc.symtab.Type = copySym.owner().primaryConstructor().tpe();
        val subst$1: scala.tools.nsc.symtab.SubstSymMap = new scala.tools.nsc.symtab.SubstSymMap($anonfun$enterSymFinishWith$1.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global(), copySym.owner().typeParams(), $anonfun$enterSymFinishWith$1.this.tparams$2.map((new /*anonymous class*/ $anonfun$4($anonfun$enterSymFinishWith$1.this): Function1), immutable.this.List.canBuildFrom()).$asInstanceOf[List]());
        $anonfun$enterSymFinishWith$1.this.tree$2.$asInstanceOf[scala.tools.nsc.ast.DefDef]().vparamss().zip(constrType.paramss(), immutable.this.List.canBuildFrom()).$asInstanceOf[scala.collection.LinearSeqLike]().foreach((new /*anonymous class*/ $anonfun$apply$1($anonfun$enterSymFinishWith$1.this, subst$1): Function1));
        $anonfun$enterSymFinishWith$1.this.ltype$1.elem.$asInstanceOf[scala.tools.nsc.typechecker.TypeCompleter]().complete($anonfun$enterSymFinishWith$1.this.sym$2)
      };
      /*synthetic*/ /*paramaccessor*/ private[this] val $outer: scala.tools.nsc.typechecker.Namer = _;
      final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = {
        $anonfun$enterSymFinishWith$1.this.apply(v1.$asInstanceOf[scala.tools.nsc.symtab.Symbol]());
        scala.runtime.BoxedUnit.UNIT
      };
      /*synthetic*/ /*paramaccessor*/ private[this] val tree$2: scala.tools.nsc.ast.Tree = _;
      /*synthetic*/ /*paramaccessor*/ private[this] val tparams$2: List = _;
      /*synthetic*/ /*paramaccessor*/ private[this] val sym$2: scala.tools.nsc.symtab.Symbol = _;
      /*synthetic*/ /*paramaccessor*/ private[this] val ltype$1: scala.runtime.ObjectRef = _;
      def this($outer: scala.tools.nsc.typechecker.Namer, tree$2: scala.tools.nsc.ast.Tree, tparams$2: List, sym$2: scala.tools.nsc.symtab.Symbol, ltype$1: scala.runtime.ObjectRef): /*anonymous class*/ $anonfun$enterSymFinishWith$1 = {
        if ($outer.eq(null))
          throw new java.lang.NullPointerException()
        else
          $anonfun$enterSymFinishWith$1.this.$outer = $outer;
        $anonfun$enterSymFinishWith$1.this.tree$2 = tree$2;
        $anonfun$enterSymFinishWith$1.this.tparams$2 = tparams$2;
        $anonfun$enterSymFinishWith$1.this.sym$2 = sym$2;
        $anonfun$enterSymFinishWith$1.this.ltype$1 = ltype$1;
        $anonfun$enterSymFinishWith$1.super.this();
        ()
      }
    };
    @SerialVersionUID(0) @serializable 
    final /*synthetic*/ class $anonfun$5 extends scala.runtime.AbstractFunction0 {
      final def apply(): scala.tools.nsc.ast.ModuleDef = $anonfun$5.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$$outer().caseModuleDef($anonfun$5.this.tree$5);
      /*synthetic*/ /*paramaccessor*/ private[this] val $outer: scala.tools.nsc.typechecker.Namer = _;
      final /*bridge*/ def apply(): java.lang.Object = $anonfun$5.this.apply();
      /*synthetic*/ /*paramaccessor*/ private[this] val tree$5: scala.tools.nsc.ast.ClassDef = _;
      def this($outer: scala.tools.nsc.typechecker.Namer, tree$5: scala.tools.nsc.ast.ClassDef): /*anonymous class*/ $anonfun$5 = {
        if ($outer.eq(null))
          throw new java.lang.NullPointerException()
        else
          $anonfun$5.this.$outer = $outer;
        $anonfun$5.this.tree$5 = tree$5;
        $anonfun$5.super.this();
        ()
      }
    };
    @SerialVersionUID(0) @serializable 
    final /*synthetic*/ class $anonfun$6 extends scala.runtime.AbstractFunction1 {
      final def apply(x0$1: scala.tools.nsc.ast.Tree): List = {
        var temp30: scala.tools.nsc.ast.Tree = x0$1;
        if (temp30.$isInstanceOf[scala.tools.nsc.ast.DefDef]())
          {
            var temp31: scala.tools.nsc.ast.DefDef = temp30.$asInstanceOf[scala.tools.nsc.ast.DefDef]();
            {
              val temp35: List = temp31.vparamss();
              if (temp31.name().==($anonfun$6.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().nme().CONSTRUCTOR()))
                {
                  val vparamss: List = temp35;
                  val vparamss: List = temp35;
                  // @todo check -- LabelDef 
                  body_0: 
                  /*(vparamss)*/{
                    vparamss.flatten(scala.this.Predef.conforms()).$asInstanceOf[List]()
                  };
                  /*EmptyTree*/
                }
              else
                // @todo check -- LabelDef 
                failCont_1: 
                /*()*/{
                  // @todo check -- LabelDef 
                  body_1: 
                  /*()*/{
                    immutable.this.Nil
                  }
                };
              /*EmptyTree*/
            };
            /*EmptyTree*/
          }
        else
           () // @todo -- goto body_1 /* vargs ()*/
          
      };
      /*synthetic*/ /*paramaccessor*/ private[this] val $outer: scala.tools.nsc.typechecker.Namer = _;
      final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = $anonfun$6.this.apply(v1.$asInstanceOf[scala.tools.nsc.ast.Tree]());
      def this($outer: scala.tools.nsc.typechecker.Namer): /*anonymous class*/ $anonfun$6 = {
        if ($outer.eq(null))
          throw new java.lang.NullPointerException()
        else
          $anonfun$6.this.$outer = $outer;
        $anonfun$6.super.this();
        ()
      }
    };
    @SerialVersionUID(0) @serializable 
    final /*synthetic*/ class $anonfun$7 extends scala.runtime.AbstractFunction1 {
      final def apply(x$10: scala.tools.nsc.ast.ValDef): Boolean = x$10.mods().hasFlag(33554432L);
      final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = scala.Boolean.box($anonfun$7.this.apply(v1.$asInstanceOf[scala.tools.nsc.ast.ValDef]()));
      def this($outer: scala.tools.nsc.typechecker.Namer): /*anonymous class*/ $anonfun$7 = {
        $anonfun$7.super.this();
        ()
      }
    };
    @SerialVersionUID(0) @serializable 
    final /*synthetic*/ class $anonfun$8 extends scala.runtime.AbstractFunction0 {
      final def apply(): scala.tools.nsc.ast.ModuleDef = $anonfun$8.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$$outer().companionModuleDef($anonfun$8.this.tree$5, immutable.this.List.apply(scala.this.Predef.wrapRefArray(Array[scala.tools.nsc.ast.Select]{$anonfun$8.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().gen().scalaScalaObjectConstr()}.$asInstanceOf[Array[java.lang.Object]]())));
      /*synthetic*/ /*paramaccessor*/ private[this] val $outer: scala.tools.nsc.typechecker.Namer = _;
      final /*bridge*/ def apply(): java.lang.Object = $anonfun$8.this.apply();
      /*synthetic*/ /*paramaccessor*/ private[this] val tree$5: scala.tools.nsc.ast.ClassDef = _;
      def this($outer: scala.tools.nsc.typechecker.Namer, tree$5: scala.tools.nsc.ast.ClassDef): /*anonymous class*/ $anonfun$8 = {
        if ($outer.eq(null))
          throw new java.lang.NullPointerException()
        else
          $anonfun$8.this.$outer = $outer;
        $anonfun$8.this.tree$5 = tree$5;
        $anonfun$8.super.this();
        ()
      }
    };
    @SerialVersionUID(0) @serializable 
    final /*synthetic*/ class $anonfun$9 extends scala.runtime.AbstractFunction1 {
      final def apply(x$12: scala.tools.nsc.ast.Tree): Boolean = $anonfun$9.this.$outer.isAnn$1(x$12, "BeanProperty");
      /*synthetic*/ /*paramaccessor*/ private[this] val $outer: scala.tools.nsc.typechecker.Namer = _;
      final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = scala.Boolean.box($anonfun$9.this.apply(v1.$asInstanceOf[scala.tools.nsc.ast.Tree]()));
      def this($outer: scala.tools.nsc.typechecker.Namer): /*anonymous class*/ $anonfun$9 = {
        if ($outer.eq(null))
          throw new java.lang.NullPointerException()
        else
          $anonfun$9.this.$outer = $outer;
        $anonfun$9.super.this();
        ()
      }
    };
    @SerialVersionUID(0) @serializable 
    final /*synthetic*/ class $anonfun$10 extends scala.runtime.AbstractFunction1 {
      final def apply(x$13: scala.tools.nsc.ast.Tree): Boolean = $anonfun$10.this.$outer.isAnn$1(x$13, "BooleanBeanProperty");
      /*synthetic*/ /*paramaccessor*/ private[this] val $outer: scala.tools.nsc.typechecker.Namer = _;
      final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = scala.Boolean.box($anonfun$10.this.apply(v1.$asInstanceOf[scala.tools.nsc.ast.Tree]()));
      def this($outer: scala.tools.nsc.typechecker.Namer): /*anonymous class*/ $anonfun$10 = {
        if ($outer.eq(null))
          throw new java.lang.NullPointerException()
        else
          $anonfun$10.this.$outer = $outer;
        $anonfun$10.super.this();
        ()
      }
    };
    @SerialVersionUID(0) @serializable 
    final /*synthetic*/ class $anonfun$apply$3 extends scala.runtime.AbstractFunction1 {
      final def apply(t: scala.tools.nsc.symtab.Type): Unit = {
        var temp93: scala.tools.nsc.symtab.Type = t;
        if (temp93.$isInstanceOf[scala.tools.nsc.symtab.TypeRef]())
          {
            var temp94: scala.tools.nsc.symtab.TypeRef = temp93.$asInstanceOf[scala.tools.nsc.symtab.TypeRef]();
            {
              var temp96: scala.tools.nsc.symtab.Symbol = temp94.sym();
              {
                val sym: scala.tools.nsc.symtab.Symbol = temp96;
                val sym: scala.tools.nsc.symtab.Symbol = temp96;
                // @todo check -- LabelDef 
                body_0: 
                /*(sym)*/{
                  sym.initialize();
                  ()
                };
                /*EmptyTree*/
              };
              /*EmptyTree*/
            };
            /*EmptyTree*/
          }
        else
          ()
      };
      final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = {
        $anonfun$apply$3.this.apply(v1.$asInstanceOf[scala.tools.nsc.symtab.Type]());
        scala.runtime.BoxedUnit.UNIT
      };
      def this($outer: /*anonymous class*/ $anonfun$typeCompleter$1): /*anonymous class*/ $anonfun$apply$3 = {
        $anonfun$apply$3.super.this();
        ()
      }
    };
    @SerialVersionUID(0) @serializable 
    final /*synthetic*/ class $anonfun$typeCompleter$1 extends scala.runtime.AbstractFunction1 {
      final def apply(sym: scala.tools.nsc.symtab.Symbol): Unit = {
        if (scala.Boolean.unbox($anonfun$typeCompleter$1.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().settings().debug().value()))
          $anonfun$typeCompleter$1.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().log("defining ".+(sym).+(symtab.Flags.flagsToString(sym.flags())).+(sym.locationString()))
        else
          ();
        val tp: scala.tools.nsc.symtab.Type = $anonfun$typeCompleter$1.this.$outer.typeSig($anonfun$typeCompleter$1.this.tree$3);
        {
          var temp98: scala.tools.nsc.symtab.Type = tp;
          if (temp98.$isInstanceOf[scala.tools.nsc.symtab.TypeBounds]())
            {
              var temp99: scala.tools.nsc.symtab.TypeBounds = temp98.$asInstanceOf[scala.tools.nsc.symtab.TypeBounds]();
              var temp100: scala.tools.nsc.symtab.Type = temp99.lo();
              {
                var temp101: scala.tools.nsc.symtab.Type = temp99.hi();
                {
                  val hi: scala.tools.nsc.symtab.Type = temp101;
                  val lo: scala.tools.nsc.symtab.Type = temp100;
                  {
                    val lo: scala.tools.nsc.symtab.Type = temp100;
                    val hi: scala.tools.nsc.symtab.Type = temp101;
                    // @todo check -- LabelDef 
                    body_0: 
                    /*(lo,hi)*/{
                      lo.foreach((new /*anonymous class*/ $anonfun$apply$3($anonfun$typeCompleter$1.this): Function1))
                    };
                    /*EmptyTree*/
                  };
                  /*EmptyTree*/
                };
                /*EmptyTree*/
              };
              /*EmptyTree*/
            }
          else
            ()
        };
        sym.setInfo(tp);
        if (sym.isAliasType().||(sym.isAbstractType()).&&(sym.hasFlag(8192L).unary_!()).&&($anonfun$typeCompleter$1.this.$outer.typer().checkNonCyclic($anonfun$typeCompleter$1.this.tree$3.pos(), tp).unary_!()))
          sym.setInfo($anonfun$typeCompleter$1.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().ErrorType())
        else
          scala.runtime.BoxedUnit.UNIT;
        if (scala.Boolean.unbox($anonfun$typeCompleter$1.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().settings().debug().value()))
          $anonfun$typeCompleter$1.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().log("defined ".+(sym))
        else
          ();
        $anonfun$typeCompleter$1.this.$outer.validate(sym)
      };
      /*synthetic*/ /*paramaccessor*/ private[this] val $outer: scala.tools.nsc.typechecker.Namer = _;
      final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = {
        $anonfun$typeCompleter$1.this.apply(v1.$asInstanceOf[scala.tools.nsc.symtab.Symbol]());
        scala.runtime.BoxedUnit.UNIT
      };
      /*synthetic*/ /*paramaccessor*/ private[this] val tree$3: scala.tools.nsc.ast.Tree = _;
      def this($outer: scala.tools.nsc.typechecker.Namer, tree$3: scala.tools.nsc.ast.Tree): /*anonymous class*/ $anonfun$typeCompleter$1 = {
        if ($outer.eq(null))
          throw new java.lang.NullPointerException()
        else
          $anonfun$typeCompleter$1.this.$outer = $outer;
        $anonfun$typeCompleter$1.this.tree$3 = tree$3;
        $anonfun$typeCompleter$1.super.this();
        ()
      }
    };
    @SerialVersionUID(0) @serializable 
    final /*synthetic*/ class $anonfun$moduleClassTypeCompleter$1 extends scala.runtime.AbstractFunction1 {
      final def apply(sym: scala.tools.nsc.symtab.Symbol): Unit = {
        val moduleSymbol: scala.tools.nsc.symtab.Symbol = $anonfun$moduleClassTypeCompleter$1.this.tree$6.symbol();
        scala.this.Predef.assert(moduleSymbol.moduleClass().==(sym));
        moduleSymbol.info();
        ();
        /*EmptyTree*/
      };
      final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = {
        $anonfun$moduleClassTypeCompleter$1.this.apply(v1.$asInstanceOf[scala.tools.nsc.symtab.Symbol]());
        scala.runtime.BoxedUnit.UNIT
      };
      /*synthetic*/ /*paramaccessor*/ private[this] val tree$6: scala.tools.nsc.ast.Tree = _;
      def this($outer: scala.tools.nsc.typechecker.Namer, tree$6: scala.tools.nsc.ast.Tree): /*anonymous class*/ $anonfun$moduleClassTypeCompleter$1 = {
        $anonfun$moduleClassTypeCompleter$1.this.tree$6 = tree$6;
        $anonfun$moduleClassTypeCompleter$1.super.this();
        ()
      }
    };
    @SerialVersionUID(0) @serializable 
    final /*synthetic*/ class $anonfun$getterTypeCompleter$1 extends scala.runtime.AbstractFunction1 {
      final def apply(sym: scala.tools.nsc.symtab.Symbol): Unit = {
        if (scala.Boolean.unbox($anonfun$getterTypeCompleter$1.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().settings().debug().value()))
          $anonfun$getterTypeCompleter$1.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().log("defining ".+(sym))
        else
          ();
        val tp: scala.tools.nsc.symtab.Type = $anonfun$getterTypeCompleter$1.this.$outer.typeSig($anonfun$getterTypeCompleter$1.this.vd$1);
        sym.setInfo(new scala.tools.nsc.symtab.PolyType($anonfun$getterTypeCompleter$1.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global(), immutable.this.Nil, tp));
        if (scala.Boolean.unbox($anonfun$getterTypeCompleter$1.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().settings().debug().value()))
          $anonfun$getterTypeCompleter$1.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().log("defined ".+(sym))
        else
          ();
        $anonfun$getterTypeCompleter$1.this.$outer.validate(sym)
      };
      /*synthetic*/ /*paramaccessor*/ private[this] val $outer: scala.tools.nsc.typechecker.Namer = _;
      final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = {
        $anonfun$getterTypeCompleter$1.this.apply(v1.$asInstanceOf[scala.tools.nsc.symtab.Symbol]());
        scala.runtime.BoxedUnit.UNIT
      };
      /*synthetic*/ /*paramaccessor*/ private[this] val vd$1: scala.tools.nsc.ast.ValDef = _;
      def this($outer: scala.tools.nsc.typechecker.Namer, vd$1: scala.tools.nsc.ast.ValDef): /*anonymous class*/ $anonfun$getterTypeCompleter$1 = {
        if ($outer.eq(null))
          throw new java.lang.NullPointerException()
        else
          $anonfun$getterTypeCompleter$1.this.$outer = $outer;
        $anonfun$getterTypeCompleter$1.this.vd$1 = vd$1;
        $anonfun$getterTypeCompleter$1.super.this();
        ()
      }
    };
    @SerialVersionUID(0) @serializable 
    final /*synthetic*/ class $anonfun$setterTypeCompleter$1 extends scala.runtime.AbstractFunction1 {
      final def apply(sym: scala.tools.nsc.symtab.Symbol): Unit = {
        if (scala.Boolean.unbox($anonfun$setterTypeCompleter$1.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().settings().debug().value()))
          $anonfun$setterTypeCompleter$1.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().log("defining ".+(sym))
        else
          ();
        val param: scala.tools.nsc.symtab.Symbol = sym.newSyntheticValueParam($anonfun$setterTypeCompleter$1.this.$outer.typeSig($anonfun$setterTypeCompleter$1.this.vd$2));
        sym.setInfo(new scala.tools.nsc.symtab.MethodType($anonfun$setterTypeCompleter$1.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global(), immutable.this.List.apply(scala.this.Predef.wrapRefArray(Array[scala.tools.nsc.symtab.Symbol]{param}.$asInstanceOf[Array[java.lang.Object]]())), $anonfun$setterTypeCompleter$1.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().definitions().UnitClass().tpe()));
        if (scala.Boolean.unbox($anonfun$setterTypeCompleter$1.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().settings().debug().value()))
          $anonfun$setterTypeCompleter$1.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().log("defined ".+(sym))
        else
          ();
        $anonfun$setterTypeCompleter$1.this.$outer.validate(sym)
      };
      /*synthetic*/ /*paramaccessor*/ private[this] val $outer: scala.tools.nsc.typechecker.Namer = _;
      final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = {
        $anonfun$setterTypeCompleter$1.this.apply(v1.$asInstanceOf[scala.tools.nsc.symtab.Symbol]());
        scala.runtime.BoxedUnit.UNIT
      };
      /*synthetic*/ /*paramaccessor*/ private[this] val vd$2: scala.tools.nsc.ast.ValDef = _;
      def this($outer: scala.tools.nsc.typechecker.Namer, vd$2: scala.tools.nsc.ast.ValDef): /*anonymous class*/ $anonfun$setterTypeCompleter$1 = {
        if ($outer.eq(null))
          throw new java.lang.NullPointerException()
        else
          $anonfun$setterTypeCompleter$1.this.$outer = $outer;
        $anonfun$setterTypeCompleter$1.this.vd$2 = vd$2;
        $anonfun$setterTypeCompleter$1.super.this();
        ()
      }
    };
    @SerialVersionUID(0) @serializable 
    final /*synthetic*/ class $anonfun$selfTypeCompleter$1 extends scala.runtime.AbstractFunction1 {
      final def apply(sym: scala.tools.nsc.symtab.Symbol): Unit = {
        var selftpe: scala.tools.nsc.symtab.Type = $anonfun$selfTypeCompleter$1.this.$outer.typer().typedType($anonfun$selfTypeCompleter$1.this.tree$7).tpe();
        if (selftpe.typeSymbol().isNonBottomSubClass(sym.owner()).unary_!())
          selftpe = $anonfun$selfTypeCompleter$1.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().intersectionType(immutable.this.List.apply(scala.this.Predef.wrapRefArray(Array[scala.tools.nsc.symtab.Type]{sym.owner().tpe(), selftpe}.$asInstanceOf[Array[java.lang.Object]]())))
        else
          ();
        sym.setInfo(selftpe);
        ();
        /*EmptyTree*/
      };
      /*synthetic*/ /*paramaccessor*/ private[this] val $outer: scala.tools.nsc.typechecker.Namer = _;
      final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = {
        $anonfun$selfTypeCompleter$1.this.apply(v1.$asInstanceOf[scala.tools.nsc.symtab.Symbol]());
        scala.runtime.BoxedUnit.UNIT
      };
      /*synthetic*/ /*paramaccessor*/ private[this] val tree$7: scala.tools.nsc.ast.Tree = _;
      def this($outer: scala.tools.nsc.typechecker.Namer, tree$7: scala.tools.nsc.ast.Tree): /*anonymous class*/ $anonfun$selfTypeCompleter$1 = {
        if ($outer.eq(null))
          throw new java.lang.NullPointerException()
        else
          $anonfun$selfTypeCompleter$1.this.$outer = $outer;
        $anonfun$selfTypeCompleter$1.this.tree$7 = tree$7;
        $anonfun$selfTypeCompleter$1.super.this();
        ()
      }
    };
    @SerialVersionUID(0) @serializable 
    final /*synthetic*/ class $anonfun$apply$4 extends scala.runtime.AbstractFunction1 {
      final def apply(param: scala.tools.nsc.ast.ValDef): scala.tools.nsc.symtab.Symbol = $anonfun$apply$4.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$$outer().enterValueParam$1(param, $anonfun$apply$4.this.$outer.owner$1);
      /*synthetic*/ /*paramaccessor*/ private[this] val $outer: /*anonymous class*/ $anonfun$enterValueParams$1 = _;
      final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = $anonfun$apply$4.this.apply(v1.$asInstanceOf[scala.tools.nsc.ast.ValDef]());
      def this($outer: /*anonymous class*/ $anonfun$enterValueParams$1): /*anonymous class*/ $anonfun$apply$4 = {
        if ($outer.eq(null))
          throw new java.lang.NullPointerException()
        else
          $anonfun$apply$4.this.$outer = $outer;
        $anonfun$apply$4.super.this();
        ()
      }
    };
    @SerialVersionUID(0) @serializable 
    final /*synthetic*/ class $anonfun$enterValueParams$1 extends scala.runtime.AbstractFunction1 {
      final def apply(x$14: List): List = x$14.map((new /*anonymous class*/ $anonfun$apply$4($anonfun$enterValueParams$1.this): Function1), immutable.this.List.canBuildFrom()).$asInstanceOf[List]();
      /*synthetic*/ /*paramaccessor*/ private[this] val $outer: scala.tools.nsc.typechecker.Namer = _;
      /*synthetic*/ /*stable*/ def scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$$outer(): scala.tools.nsc.typechecker.Namer = $anonfun$enterValueParams$1.this.$outer;
      final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = $anonfun$enterValueParams$1.this.apply(v1.$asInstanceOf[List]());
      /*synthetic*/ /*paramaccessor*/ val owner$1: scala.tools.nsc.symtab.Symbol = _;
      def this($outer: scala.tools.nsc.typechecker.Namer, owner$1: scala.tools.nsc.symtab.Symbol): /*anonymous class*/ $anonfun$enterValueParams$1 = {
        if ($outer.eq(null))
          throw new java.lang.NullPointerException()
        else
          $anonfun$enterValueParams$1.this.$outer = $outer;
        $anonfun$enterValueParams$1.this.owner$1 = owner$1;
        $anonfun$enterValueParams$1.super.this();
        ()
      }
    };
    @SerialVersionUID(0) @serializable 
    final /*synthetic*/ class $anonfun$11 extends scala.runtime.AbstractFunction1 {
      final def apply(tpt: scala.tools.nsc.ast.Tree): scala.tools.nsc.symtab.Type = $anonfun$11.this.$outer.checkParent$1(tpt);
      /*synthetic*/ /*paramaccessor*/ private[this] val $outer: scala.tools.nsc.typechecker.Namer = _;
      final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = $anonfun$11.this.apply(v1.$asInstanceOf[scala.tools.nsc.ast.Tree]());
      def this($outer: scala.tools.nsc.typechecker.Namer): /*anonymous class*/ $anonfun$11 = {
        if ($outer.eq(null))
          throw new java.lang.NullPointerException()
        else
          $anonfun$11.this.$outer = $outer;
        $anonfun$11.super.this();
        ()
      }
    };
    @SerialVersionUID(0) @serializable 
    final /*synthetic*/ class $anonfun$hasCopy$1$1 extends scala.runtime.AbstractFunction1 {
      final def apply(x$15: scala.tools.nsc.symtab.Symbol): Boolean = x$15.name().==($anonfun$hasCopy$1$1.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().nme().copy());
      /*synthetic*/ /*paramaccessor*/ private[this] val $outer: scala.tools.nsc.typechecker.Namer = _;
      final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = scala.Boolean.box($anonfun$hasCopy$1$1.this.apply(v1.$asInstanceOf[scala.tools.nsc.symtab.Symbol]()));
      def this($outer: scala.tools.nsc.typechecker.Namer): /*anonymous class*/ $anonfun$hasCopy$1$1 = {
        if ($outer.eq(null))
          throw new java.lang.NullPointerException()
        else
          $anonfun$hasCopy$1$1.this.$outer = $outer;
        $anonfun$hasCopy$1$1.super.this();
        ()
      }
    };
    @SerialVersionUID(0) @serializable 
    final /*synthetic*/ class $anonfun$templateSig$1 extends scala.runtime.AbstractFunction1 {
      final def apply(p: scala.tools.nsc.symtab.Type): Boolean = $anonfun$templateSig$1.this.$outer.hasCopy$1(p.typeSymbol().info().decls());
      /*synthetic*/ /*paramaccessor*/ private[this] val $outer: scala.tools.nsc.typechecker.Namer = _;
      final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = scala.Boolean.box($anonfun$templateSig$1.this.apply(v1.$asInstanceOf[scala.tools.nsc.symtab.Type]()));
      def this($outer: scala.tools.nsc.typechecker.Namer): /*anonymous class*/ $anonfun$templateSig$1 = {
        if ($outer.eq(null))
          throw new java.lang.NullPointerException()
        else
          $anonfun$templateSig$1.this.$outer = $outer;
        $anonfun$templateSig$1.super.this();
        ()
      }
    };
    @SerialVersionUID(0) @serializable 
    final /*synthetic*/ class $anonfun$templateSig$2 extends scala.runtime.AbstractFunction1 {
      final def apply(x$16: scala.tools.nsc.symtab.Type): List = x$16.baseClasses();
      final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = $anonfun$templateSig$2.this.apply(v1.$asInstanceOf[scala.tools.nsc.symtab.Type]());
      def this($outer: scala.tools.nsc.typechecker.Namer): /*anonymous class*/ $anonfun$templateSig$2 = {
        $anonfun$templateSig$2.super.this();
        ()
      }
    };
    @SerialVersionUID(0) @serializable 
    final /*synthetic*/ class $anonfun$templateSig$3 extends scala.runtime.AbstractFunction1 {
      final def apply(bc: scala.tools.nsc.symtab.Symbol): Boolean = $anonfun$templateSig$3.this.$outer.hasCopy$1(bc.info().decls());
      /*synthetic*/ /*paramaccessor*/ private[this] val $outer: scala.tools.nsc.typechecker.Namer = _;
      final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = scala.Boolean.box($anonfun$templateSig$3.this.apply(v1.$asInstanceOf[scala.tools.nsc.symtab.Symbol]()));
      def this($outer: scala.tools.nsc.typechecker.Namer): /*anonymous class*/ $anonfun$templateSig$3 = {
        if ($outer.eq(null))
          throw new java.lang.NullPointerException()
        else
          $anonfun$templateSig$3.this.$outer = $outer;
        $anonfun$templateSig$3.super.this();
        ()
      }
    };
    final class treeTrans extends scala.tools.nsc.symtab.TypeMapTransformer with ScalaObject {
      override def transform(tree$8: scala.tools.nsc.ast.Tree): scala.tools.nsc.ast.Tree = {
        var temp127: scala.tools.nsc.ast.Tree = tree$8;
        if (temp127.$isInstanceOf[scala.tools.nsc.ast.Ident]())
          {
            var temp128: scala.tools.nsc.ast.Ident = temp127.$asInstanceOf[scala.tools.nsc.ast.Ident]();
            var temp129: scala.tools.nsc.symtab.Name = temp128.name();
            {
              val name: scala.tools.nsc.symtab.Name = temp129;
              if (treeTrans.this.gd2$1(name, tree$8))
                {
                  val name: scala.tools.nsc.symtab.Name = temp129;
                  // @todo check -- LabelDef 
                  body_0: 
                  /*(name)*/{
                    val dtpe: scala.tools.nsc.symtab.DeBruijnIndex = treeTrans.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$anon$$debruijnFor(tree$8.symbol());
                    val dsym: scala.tools.nsc.symtab.TermSymbol = treeTrans.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$anon$$$outer().context().owner().newLocalDummy(tree$8.symbol().pos()).newValue(tree$8.symbol().pos(), name);
                    dsym.setFlag(8192L);
                    dsym.setInfo(dtpe);
                    new scala.tools.nsc.ast.Ident(treeTrans.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$anon$$$outer().scala$tools$nsc$typechecker$Namers$Namer$$$outer().global(), name).setSymbol(dsym).copyAttrs(tree$8).setType(dtpe)
                  }
                }
              else
                {
                  val tree: scala.tools.nsc.ast.Tree = temp128;
                  val tree: scala.tools.nsc.ast.Tree = temp128;
                  // @todo check -- LabelDef 
                  body_1: 
                  /*(tree)*/{
                    treeTrans.super.transform(tree)
                  };
                  /*EmptyTree*/
                }
            };
            /*EmptyTree*/
          }
        else
           () // @todo -- goto body_1 /* vargs (temp127)*/
          
      };
      /*synthetic*/ /*paramaccessor*/ private[this] val $outer: /*anonymous class*/ $anon$4 = _;
      final /*synthetic*/ private[this] def gd2$1(x$1: scala.tools.nsc.symtab.Name, tree$8: scala.tools.nsc.ast.Tree): Boolean = treeTrans.this.$outer.vparams$1.contains(tree$8.symbol());
      def this($outer: /*anonymous class*/ $anon$4): object scala.tools.nsc.typechecker.treeTrans = {
        if ($outer.eq(null))
          throw new java.lang.NullPointerException()
        else
          treeTrans.this.$outer = $outer;
        treeTrans.super.this($outer);
        ()
      }
    };
    final class $anon$4 extends scala.tools.nsc.symtab.TypeMap {
      final def scala$tools$nsc$typechecker$Namers$Namer$$anon$$debruijnFor(param: scala.tools.nsc.symtab.Symbol): scala.tools.nsc.symtab.DeBruijnIndex = new scala.tools.nsc.symtab.DeBruijnIndex($anon$4.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global(), $anon$4.this.level$1, $anon$4.this.vparams$1.indexOf(param));
      def apply(tp: scala.tools.nsc.symtab.Type): scala.tools.nsc.symtab.Type = {
        var temp120: scala.tools.nsc.symtab.Type = tp;
        if (temp120.$isInstanceOf[scala.tools.nsc.symtab.SingleType]())
          {
            var temp121: scala.tools.nsc.symtab.SingleType = temp120.$asInstanceOf[scala.tools.nsc.symtab.SingleType]();
            {
              var temp123: scala.tools.nsc.symtab.Symbol = temp121.sym();
              {
                val sym: scala.tools.nsc.symtab.Symbol = temp123;
                val sym: scala.tools.nsc.symtab.Symbol = temp123;
                // @todo check -- LabelDef 
                body_0: 
                /*(sym)*/{
                  if (scala.Boolean.unbox($anon$4.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().settings().Xexperimental().value()).&&(sym.owner().==($anon$4.this.meth$1)).&&($anon$4.this.vparams$1.contains(sym)))
                    $anon$4.this.scala$tools$nsc$typechecker$Namers$Namer$$anon$$debruijnFor(sym)
                  else
                    tp
                };
                /*EmptyTree*/
              };
              /*EmptyTree*/
            };
            /*EmptyTree*/
          }
        else
          if (temp120.$isInstanceOf[scala.tools.nsc.symtab.MethodType]())
            {
              var temp124: scala.tools.nsc.symtab.MethodType = temp120.$asInstanceOf[scala.tools.nsc.symtab.MethodType]();
              val temp125: List = temp124.params();
              {
                var temp126: scala.tools.nsc.symtab.Type = temp124.resultType();
                {
                  val restpe: scala.tools.nsc.symtab.Type = temp126;
                  val params: List = temp125;
                  {
                    val params: List = temp125;
                    val restpe: scala.tools.nsc.symtab.Type = temp126;
                    // @todo check -- LabelDef 
                    body_1: 
                    /*(params,restpe)*/{
                      val params1: List = this.mapOver(params);
                      val restpe1: scala.tools.nsc.symtab.Type = $anon$4.this.$outer.convertToDeBruijn$1($anon$4.this.vparams$1, $anon$4.this.level$1.+(1), $anon$4.this.meth$1).apply(restpe).$asInstanceOf[scala.tools.nsc.symtab.Type]();
                      if (params1.eq(params).&&(restpe1.eq(restpe)))
                        tp
                      else
                        $anon$4.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().copyMethodType(tp, params1, restpe1)
                    };
                    /*EmptyTree*/
                  };
                  /*EmptyTree*/
                };
                /*EmptyTree*/
              };
              /*EmptyTree*/
            }
          else
            // @todo check -- LabelDef 
            body_2: 
            /*()*/{
              $anon$4.this.mapOver(tp)
            }
      };
      /*synthetic*/ private[this] var treeTrans$module: object scala.tools.nsc.typechecker.treeTrans = _;
      final private /*stable*/ def treeTrans(): object scala.tools.nsc.typechecker.treeTrans = {
        if ($anon$4.this.treeTrans$module.eq(null))
          $anon$4.this.treeTrans$module = new object scala.tools.nsc.typechecker.treeTrans($anon$4.this);
        $anon$4.this.treeTrans$module
      };
      override def mapOver(arg: scala.tools.nsc.ast.Tree): Some = new Some($anon$4.this.treeTrans().transform(arg));
      /*synthetic*/ /*paramaccessor*/ private[this] val $outer: scala.tools.nsc.typechecker.Namer = _;
      /*synthetic*/ /*stable*/ def scala$tools$nsc$typechecker$Namers$Namer$$anon$$$outer(): scala.tools.nsc.typechecker.Namer = $anon$4.this.$outer;
      override /*bridge*/ def mapOver(tree: scala.tools.nsc.ast.Tree): Option = $anon$4.this.mapOver(tree);
      /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = $anon$4.this.apply(v1.$asInstanceOf[scala.tools.nsc.symtab.Type]());
      /*synthetic*/ /*paramaccessor*/ private[this] val meth$1: scala.tools.nsc.symtab.Symbol = _;
      /*synthetic*/ /*paramaccessor*/ val vparams$1: List = _;
      /*synthetic*/ /*paramaccessor*/ private[this] val level$1: Int = _;
      def this($outer: scala.tools.nsc.typechecker.Namer, meth$1: scala.tools.nsc.symtab.Symbol, vparams$1: List, level$1: Int): /*anonymous class*/ $anon$4 = {
        if ($outer.eq(null))
          throw new java.lang.NullPointerException()
        else
          $anon$4.this.$outer = $outer;
        $anon$4.this.meth$1 = meth$1;
        $anon$4.this.vparams$1 = vparams$1;
        $anon$4.this.level$1 = level$1;
        $anon$4.super.this($outer.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global());
        ()
      }
    };
    @SerialVersionUID(0) @serializable 
    final /*synthetic*/ class $anonfun$traverse$1 extends scala.runtime.AbstractFunction1 {
      final def apply(x$17: List): Boolean = x$17.contains($anonfun$traverse$1.this.sym$5);
      final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = scala.Boolean.box($anonfun$traverse$1.this.apply(v1.$asInstanceOf[List]()));
      /*synthetic*/ /*paramaccessor*/ private[this] val sym$5: scala.tools.nsc.symtab.Symbol = _;
      def this($outer: /*anonymous class*/ $anon$2, sym$5: scala.tools.nsc.symtab.Symbol): /*anonymous class*/ $anonfun$traverse$1 = {
        $anonfun$traverse$1.this.sym$5 = sym$5;
        $anonfun$traverse$1.super.this();
        ()
      }
    };
    final class $anon$2 extends scala.tools.nsc.symtab.TypeTraverser {
      def traverse(tp: scala.tools.nsc.symtab.Type): Unit = {
        var temp130: scala.tools.nsc.symtab.Type = tp;
        if (temp130.$isInstanceOf[scala.tools.nsc.symtab.SingleType]())
          {
            var temp131: scala.tools.nsc.symtab.SingleType = temp130.$asInstanceOf[scala.tools.nsc.symtab.SingleType]();
            {
              var temp133: scala.tools.nsc.symtab.Symbol = temp131.sym();
              {
                val sym$5: scala.tools.nsc.symtab.Symbol = temp133;
                val sym$5: scala.tools.nsc.symtab.Symbol = temp133;
                while (sym$5.owner().==($anon$2.this.meth$1).&&($anon$2.this.vparamSymss$1.elem.$asInstanceOf[List]().exists((new /*anonymous class*/ $anonfun$traverse$1($anon$2.this, sym$5): Function1))))$anon$2.this.$outer.context().error(sym$5.pos(), "illegal dependent method type".+(if (scala.Boolean.unbox($anon$2.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().settings().Xexperimental().value()))
                  ": parameter appears in the type of another parameter in the same section or an earlier one"
                else
                  ""))
              ;
              /*EmptyTree*/
            };
            /*EmptyTree*/
          };
          /*EmptyTree*/
        }
      else
        // @todo check -- LabelDef 
        body_1: 
        /*()*/{
          $anon$2.this.mapOver(tp)
        };
      this;
      ();
      /*EmptyTree*/
    };
    /*synthetic*/ /*paramaccessor*/ private[this] val $outer: scala.tools.nsc.typechecker.Namer = _;
    /*synthetic*/ /*paramaccessor*/ private[this] val meth$1: scala.tools.nsc.symtab.Symbol = _;
    /*synthetic*/ /*paramaccessor*/ private[this] val vparamSymss$1: scala.runtime.ObjectRef = _;
    def this($outer: scala.tools.nsc.typechecker.Namer, meth$1: scala.tools.nsc.symtab.Symbol, vparamSymss$1: scala.runtime.ObjectRef): /*anonymous class*/ $anon$2 = {
      if ($outer.eq(null))
        throw new java.lang.NullPointerException()
      else
        $anon$2.this.$outer = $outer;
      $anon$2.this.meth$1 = meth$1;
      $anon$2.this.vparamSymss$1 = vparamSymss$1;
      $anon$2.super.this($outer.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global());
      ()
    }
  };
  @SerialVersionUID(0) @serializable 
  final /*synthetic*/ class $anonfun$12 extends scala.runtime.AbstractFunction1 {
    final def apply(vparam: scala.tools.nsc.symtab.Symbol): scala.tools.nsc.symtab.Symbol = if ($anonfun$12.this.meth$1.hasFlag(1048576L))
      vparam.setInfo($anonfun$12.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().objToAny(vparam.tpe()))
    else
      vparam;
    /*synthetic*/ /*paramaccessor*/ private[this] val $outer: scala.tools.nsc.typechecker.Namer = _;
    final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = $anonfun$12.this.apply(v1.$asInstanceOf[scala.tools.nsc.symtab.Symbol]());
    /*synthetic*/ /*paramaccessor*/ private[this] val meth$1: scala.tools.nsc.symtab.Symbol = _;
    def this($outer: scala.tools.nsc.typechecker.Namer, meth$1: scala.tools.nsc.symtab.Symbol): /*anonymous class*/ $anonfun$12 = {
      if ($outer.eq(null))
        throw new java.lang.NullPointerException()
      else
        $anonfun$12.this.$outer = $outer;
      $anonfun$12.this.meth$1 = meth$1;
      $anonfun$12.super.this();
      ()
    }
  };
  @SerialVersionUID(0) @serializable 
  final /*synthetic*/ class $anonfun$thisMethodType$1$1 extends scala.runtime.AbstractFunction2 {
    final def apply(vparams: List, restpe: scala.tools.nsc.symtab.Type): scala.tools.nsc.symtab.MethodType = $anonfun$thisMethodType$1$1.this.$outer.makeMethodType$1(vparams, restpe, $anonfun$thisMethodType$1$1.this.meth$1);
    /*synthetic*/ /*paramaccessor*/ private[this] val $outer: scala.tools.nsc.typechecker.Namer = _;
    final /*bridge*/ def apply(v1: java.lang.Object, v2: java.lang.Object): java.lang.Object = $anonfun$thisMethodType$1$1.this.apply(v1.$asInstanceOf[List](), v2.$asInstanceOf[scala.tools.nsc.symtab.Type]());
    /*synthetic*/ /*paramaccessor*/ private[this] val meth$1: scala.tools.nsc.symtab.Symbol = _;
    def this($outer: scala.tools.nsc.typechecker.Namer, meth$1: scala.tools.nsc.symtab.Symbol): /*anonymous class*/ $anonfun$thisMethodType$1$1 = {
      if ($outer.eq(null))
        throw new java.lang.NullPointerException()
      else
        $anonfun$thisMethodType$1$1.this.$outer = $outer;
      $anonfun$thisMethodType$1$1.this.meth$1 = meth$1;
      $anonfun$thisMethodType$1$1.super.this();
      ()
    }
  };
  @SerialVersionUID(0) @serializable 
  final /*synthetic*/ class $anonfun$apply$5 extends scala.runtime.AbstractFunction1 {
    final def apply(x$18: scala.tools.nsc.ast.TypeDef): scala.tools.nsc.symtab.Symbol = x$18.symbol();
    final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = $anonfun$apply$5.this.apply(v1.$asInstanceOf[scala.tools.nsc.ast.TypeDef]());
    def this($outer: /*anonymous class*/ $anonfun$overriddenSymbol$1$1): /*anonymous class*/ $anonfun$apply$5 = {
      $anonfun$apply$5.super.this();
      ()
    }
  };
  @SerialVersionUID(0) @serializable 
  final /*synthetic*/ class $anonfun$overriddenSymbol$1$1 extends scala.runtime.AbstractFunction1 {
    final def apply(sym: scala.tools.nsc.symtab.Symbol): Boolean = sym.!=($anonfun$overriddenSymbol$1$1.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().NoSymbol()).&&($anonfun$overriddenSymbol$1$1.this.site$1.memberType(sym).matches($anonfun$overriddenSymbol$1$1.this.$outer.thisMethodType$1($anonfun$overriddenSymbol$1$1.this.resultPt$1.elem.$asInstanceOf[scala.tools.nsc.symtab.Type](), $anonfun$overriddenSymbol$1$1.this.meth$1, $anonfun$overriddenSymbol$1$1.this.tparamSyms$1, $anonfun$overriddenSymbol$1$1.this.vparamSymss$1, $anonfun$overriddenSymbol$1$1.this.checkDependencies$1).substSym($anonfun$overriddenSymbol$1$1.this.tparams$3.map((new /*anonymous class*/ $anonfun$apply$5($anonfun$overriddenSymbol$1$1.this): Function1), immutable.this.List.canBuildFrom()).$asInstanceOf[List](), $anonfun$overriddenSymbol$1$1.this.tparamSyms$1)));
    /*synthetic*/ /*paramaccessor*/ private[this] val $outer: scala.tools.nsc.typechecker.Namer = _;
    final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = scala.Boolean.box($anonfun$overriddenSymbol$1$1.this.apply(v1.$asInstanceOf[scala.tools.nsc.symtab.Symbol]()));
    /*synthetic*/ /*paramaccessor*/ private[this] val tparams$3: List = _;
    /*synthetic*/ /*paramaccessor*/ private[this] val meth$1: scala.tools.nsc.symtab.Symbol = _;
    /*synthetic*/ /*paramaccessor*/ private[this] val tparamSyms$1: List = _;
    /*synthetic*/ /*paramaccessor*/ private[this] val vparamSymss$1: scala.runtime.ObjectRef = _;
    /*synthetic*/ /*paramaccessor*/ private[this] val checkDependencies$1: scala.tools.nsc.symtab.TypeTraverser = _;
    /*synthetic*/ /*paramaccessor*/ private[this] val resultPt$1: scala.runtime.ObjectRef = _;
    /*synthetic*/ /*paramaccessor*/ private[this] val site$1: scala.tools.nsc.symtab.Type = _;
    def this($outer: scala.tools.nsc.typechecker.Namer, tparams$3: List, meth$1: scala.tools.nsc.symtab.Symbol, tparamSyms$1: List, vparamSymss$1: scala.runtime.ObjectRef, checkDependencies$1: scala.tools.nsc.symtab.TypeTraverser, resultPt$1: scala.runtime.ObjectRef, site$1: scala.tools.nsc.symtab.Type): /*anonymous class*/ $anonfun$overriddenSymbol$1$1 = {
      if ($outer.eq(null))
        throw new java.lang.NullPointerException()
      else
        $anonfun$overriddenSymbol$1$1.this.$outer = $outer;
      $anonfun$overriddenSymbol$1$1.this.tparams$3 = tparams$3;
      $anonfun$overriddenSymbol$1$1.this.meth$1 = meth$1;
      $anonfun$overriddenSymbol$1$1.this.tparamSyms$1 = tparamSyms$1;
      $anonfun$overriddenSymbol$1$1.this.vparamSymss$1 = vparamSymss$1;
      $anonfun$overriddenSymbol$1$1.this.checkDependencies$1 = checkDependencies$1;
      $anonfun$overriddenSymbol$1$1.this.resultPt$1 = resultPt$1;
      $anonfun$overriddenSymbol$1$1.this.site$1 = site$1;
      $anonfun$overriddenSymbol$1$1.super.this();
      ()
    }
  };
  @SerialVersionUID(0) @serializable 
  final /*synthetic*/ class $anonfun$apply$6 extends scala.runtime.AbstractFunction1 {
    final def apply(x$20: scala.tools.nsc.ast.ValDef): Boolean = x$20.tpt().isEmpty();
    final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = scala.Boolean.box($anonfun$apply$6.this.apply(v1.$asInstanceOf[scala.tools.nsc.ast.ValDef]()));
    def this($outer: /*anonymous class*/ $anonfun$/*method*/Sig$1): /*anonymous class*/ $anonfun$apply$6 = {
      $anonfun$apply$6.super.this();
      ()
    }
  };
  @SerialVersionUID(0) @serializable 
  final /*synthetic*/ class $anonfun$methodSig$1 extends scala.runtime.AbstractFunction1 {
    final def apply(x$19: List): Boolean = x$19.exists((new /*anonymous class*/ $anonfun$apply$6($anonfun$methodSig$1.this): Function1));
    final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = scala.Boolean.box($anonfun$methodSig$1.this.apply(v1.$asInstanceOf[List]()));
    def this($outer: scala.tools.nsc.typechecker.Namer): /*anonymous class*/ $anonfun$/*method*/Sig$1 = {
      $anonfun$methodSig$1.super.this();
      ()
    }
  };
  @SerialVersionUID(0) @serializable 
  final /*synthetic*/ class $anonfun$apply$7 extends scala.runtime.AbstractFunction1 {
    final def apply(vparam: scala.tools.nsc.ast.ValDef): java.lang.Object = if (vparam.tpt().isEmpty())
      vparam.symbol().setInfo($anonfun$apply$7.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$$outer().scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().WildcardType())
    else
      scala.runtime.BoxedUnit.UNIT;
    /*synthetic*/ /*paramaccessor*/ private[this] val $outer: /*anonymous class*/ $anonfun$/*method*/Sig$2 = _;
    final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = $anonfun$apply$7.this.apply(v1.$asInstanceOf[scala.tools.nsc.ast.ValDef]());
    def this($outer: /*anonymous class*/ $anonfun$/*method*/Sig$2): /*anonymous class*/ $anonfun$apply$7 = {
      if ($outer.eq(null))
        throw new java.lang.NullPointerException()
      else
        $anonfun$apply$7.this.$outer = $outer;
      $anonfun$apply$7.super.this();
      ()
    }
  };
  @SerialVersionUID(0) @serializable 
  final /*synthetic*/ class $anonfun$methodSig$2 extends scala.runtime.AbstractFunction1 {
    final def apply(vparams: List): Unit = vparams.foreach((new /*anonymous class*/ $anonfun$apply$7($anonfun$methodSig$2.this): Function1));
    /*synthetic*/ /*paramaccessor*/ private[this] val $outer: scala.tools.nsc.typechecker.Namer = _;
    /*synthetic*/ /*stable*/ def scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$$outer(): scala.tools.nsc.typechecker.Namer = $anonfun$methodSig$2.this.$outer;
    final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = {
      $anonfun$methodSig$2.this.apply(v1.$asInstanceOf[List]());
      scala.runtime.BoxedUnit.UNIT
    };
    def this($outer: scala.tools.nsc.typechecker.Namer): /*anonymous class*/ $anonfun$/*method*/Sig$2 = {
      if ($outer.eq(null))
        throw new java.lang.NullPointerException()
      else
        $anonfun$methodSig$2.this.$outer = $outer;
      $anonfun$methodSig$2.super.this();
      ()
    }
  };
  @SerialVersionUID(0) @serializable 
  final /*synthetic*/ class $anonfun$apply$8 extends scala.runtime.AbstractFunction1 {
    final def apply(vparam: scala.tools.nsc.ast.ValDef): Unit = {
      if (vparam.tpt().isEmpty())
        {
          vparam.tpt().defineType($anonfun$apply$8.this.pfs$1.elem.$asInstanceOf[List]().head().$asInstanceOf[scala.tools.nsc.symtab.Type]());
          vparam.tpt().setPos(vparam.pos().focus());
          vparam.symbol().setInfo($anonfun$apply$8.this.pfs$1.elem.$asInstanceOf[List]().head().$asInstanceOf[scala.tools.nsc.symtab.Type]())
        }
      else
        scala.runtime.BoxedUnit.UNIT;
      $anonfun$apply$8.this.pfs$1.elem = $anonfun$apply$8.this.pfs$1.elem.$asInstanceOf[List]().tail().$asInstanceOf[List]()
    };
    final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = {
      $anonfun$apply$8.this.apply(v1.$asInstanceOf[scala.tools.nsc.ast.ValDef]());
      scala.runtime.BoxedUnit.UNIT
    };
    /*synthetic*/ /*paramaccessor*/ private[this] val pfs$1: scala.runtime.ObjectRef = _;
    def this($outer: /*anonymous class*/ $anonfun$/*method*/Sig$3, pfs$1: scala.runtime.ObjectRef): /*anonymous class*/ $anonfun$apply$8 = {
      $anonfun$apply$8.this.pfs$1 = pfs$1;
      $anonfun$apply$8.super.this();
      ()
    }
  };
  @SerialVersionUID(0) @serializable 
  final /*synthetic*/ class $anonfun$methodSig$3 extends scala.runtime.AbstractFunction1 {
    final def apply(vparams: List): Unit = {
      var pfs$1: scala.runtime.ObjectRef = new scala.runtime.ObjectRef($anonfun$methodSig$3.this.resultPt$1.elem.$asInstanceOf[scala.tools.nsc.symtab.Type]().paramTypes());
      vparams.foreach((new /*anonymous class*/ $anonfun$apply$8($anonfun$methodSig$3.this, pfs$1): Function1));
      $anonfun$methodSig$3.this.resultPt$1.elem = $anonfun$methodSig$3.this.resultPt$1.elem.$asInstanceOf[scala.tools.nsc.symtab.Type]().resultType()
    };
    final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = {
      $anonfun$methodSig$3.this.apply(v1.$asInstanceOf[List]());
      scala.runtime.BoxedUnit.UNIT
    };
    /*synthetic*/ /*paramaccessor*/ private[this] val resultPt$1: scala.runtime.ObjectRef = _;
    def this($outer: scala.tools.nsc.typechecker.Namer, resultPt$1: scala.runtime.ObjectRef): /*anonymous class*/ $anonfun$/*method*/Sig$3 = {
      $anonfun$methodSig$3.this.resultPt$1 = resultPt$1;
      $anonfun$methodSig$3.super.this();
      ()
    }
  };
  @SerialVersionUID(0) @serializable 
  final /*synthetic*/ class $anonfun$methodSig$4 extends scala.runtime.AbstractFunction1 {
    final def apply(x$21: scala.tools.nsc.symtab.Symbol): Boolean = x$21.info().$isInstanceOf[scala.tools.nsc.symtab.MethodType]();
    final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = scala.Boolean.box($anonfun$methodSig$4.this.apply(v1.$asInstanceOf[scala.tools.nsc.symtab.Symbol]()));
    def this($outer: scala.tools.nsc.typechecker.Namer): /*anonymous class*/ $anonfun$/*method*/Sig$4 = {
      $anonfun$methodSig$4.super.this();
      ()
    }
  };
  @SerialVersionUID(0) @serializable 
  final /*synthetic*/ class $anonfun$apply$9 extends scala.runtime.AbstractFunction1 {
    final def apply(vparam: scala.tools.nsc.ast.ValDef): Boolean = vparam.tpt().isEmpty();
    final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = scala.Boolean.box($anonfun$apply$9.this.apply(v1.$asInstanceOf[scala.tools.nsc.ast.ValDef]()));
    def this($outer: /*anonymous class*/ $anonfun$/*method*/Sig$5): /*anonymous class*/ $anonfun$apply$9 = {
      $anonfun$apply$9.super.this();
      ()
    }
  };
  @SerialVersionUID(0) @serializable 
  final /*synthetic*/ class $anonfun$apply$10 extends scala.runtime.AbstractFunction1 {
    final def apply(vparam: scala.tools.nsc.ast.ValDef): scala.tools.nsc.ast.Tree = {
      $anonfun$apply$10.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$$outer().context().error(vparam.pos(), "missing parameter type");
      vparam.tpt().defineType($anonfun$apply$10.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$$outer().scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().ErrorType())
    };
    /*synthetic*/ /*paramaccessor*/ private[this] val $outer: /*anonymous class*/ $anonfun$/*method*/Sig$5 = _;
    final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = $anonfun$apply$10.this.apply(v1.$asInstanceOf[scala.tools.nsc.ast.ValDef]());
    def this($outer: /*anonymous class*/ $anonfun$/*method*/Sig$5): /*anonymous class*/ $anonfun$apply$10 = {
      if ($outer.eq(null))
        throw new java.lang.NullPointerException()
      else
        $anonfun$apply$10.this.$outer = $outer;
      $anonfun$apply$10.super.this();
      ()
    }
  };
  @SerialVersionUID(0) @serializable 
  final /*synthetic*/ class $anonfun$methodSig$5 extends scala.runtime.AbstractFunction1 {
    final def apply(vparams: List): Unit = vparams.withFilter((new /*anonymous class*/ $anonfun$apply$9($anonfun$methodSig$5.this): Function1)).foreach((new /*anonymous class*/ $anonfun$apply$10($anonfun$methodSig$5.this): Function1));
    /*synthetic*/ /*paramaccessor*/ private[this] val $outer: scala.tools.nsc.typechecker.Namer = _;
    /*synthetic*/ /*stable*/ def scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$$outer(): scala.tools.nsc.typechecker.Namer = $anonfun$methodSig$5.this.$outer;
    final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = {
      $anonfun$methodSig$5.this.apply(v1.$asInstanceOf[List]());
      scala.runtime.BoxedUnit.UNIT
    };
    def this($outer: scala.tools.nsc.typechecker.Namer): /*anonymous class*/ $anonfun$/*method*/Sig$5 = {
      if ($outer.eq(null))
        throw new java.lang.NullPointerException()
      else
        $anonfun$methodSig$5.this.$outer = $outer;
      $anonfun$methodSig$5.super.this();
      ()
    }
  };
  @SerialVersionUID(0) @serializable 
  final /*synthetic*/ class $anonfun$methodSig$6 extends scala.runtime.AbstractFunction0 {
    final def apply(): scala.tools.nsc.symtab.Symbol = $anonfun$methodSig$6.this.$outer.overriddenSymbol$1($anonfun$methodSig$6.this.tparams$3, $anonfun$methodSig$6.this.meth$1, $anonfun$methodSig$6.this.tparamSyms$1, $anonfun$methodSig$6.this.vparamSymss$1, $anonfun$methodSig$6.this.checkDependencies$1, $anonfun$methodSig$6.this.resultPt$1, $anonfun$methodSig$6.this.site$1);
    /*synthetic*/ /*paramaccessor*/ private[this] val $outer: scala.tools.nsc.typechecker.Namer = _;
    final /*bridge*/ def apply(): java.lang.Object = $anonfun$methodSig$6.this.apply();
    /*synthetic*/ /*paramaccessor*/ private[this] val tparams$3: List = _;
    /*synthetic*/ /*paramaccessor*/ private[this] val meth$1: scala.tools.nsc.symtab.Symbol = _;
    /*synthetic*/ /*paramaccessor*/ private[this] val tparamSyms$1: List = _;
    /*synthetic*/ /*paramaccessor*/ private[this] val vparamSymss$1: scala.runtime.ObjectRef = _;
    /*synthetic*/ /*paramaccessor*/ private[this] val checkDependencies$1: scala.tools.nsc.symtab.TypeTraverser = _;
    /*synthetic*/ /*paramaccessor*/ private[this] val resultPt$1: scala.runtime.ObjectRef = _;
    /*synthetic*/ /*paramaccessor*/ private[this] val site$1: scala.tools.nsc.symtab.Type = _;
    def this($outer: scala.tools.nsc.typechecker.Namer, tparams$3: List, meth$1: scala.tools.nsc.symtab.Symbol, tparamSyms$1: List, vparamSymss$1: scala.runtime.ObjectRef, checkDependencies$1: scala.tools.nsc.symtab.TypeTraverser, resultPt$1: scala.runtime.ObjectRef, site$1: scala.tools.nsc.symtab.Type): /*anonymous class*/ $anonfun$/*method*/Sig$6 = {
      if ($outer.eq(null))
        throw new java.lang.NullPointerException()
      else
        $anonfun$methodSig$6.this.$outer = $outer;
      $anonfun$methodSig$6.this.tparams$3 = tparams$3;
      $anonfun$methodSig$6.this.meth$1 = meth$1;
      $anonfun$methodSig$6.this.tparamSyms$1 = tparamSyms$1;
      $anonfun$methodSig$6.this.vparamSymss$1 = vparamSymss$1;
      $anonfun$methodSig$6.this.checkDependencies$1 = checkDependencies$1;
      $anonfun$methodSig$6.this.resultPt$1 = resultPt$1;
      $anonfun$methodSig$6.this.site$1 = site$1;
      $anonfun$methodSig$6.super.this();
      ()
    }
  };
  @SerialVersionUID(0) @serializable 
  final /*synthetic*/ class $anonfun$13 extends scala.runtime.AbstractFunction1 {
    final def apply(x$22: scala.tools.nsc.ast.TypeDef): scala.tools.nsc.symtab.Symbol = x$22.symbol();
    final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = $anonfun$13.this.apply(v1.$asInstanceOf[scala.tools.nsc.ast.TypeDef]());
    def this($outer: scala.tools.nsc.typechecker.Namer): /*anonymous class*/ $anonfun$13 = {
      $anonfun$13.super.this();
      ()
    }
  };
  @SerialVersionUID(0) @serializable 
  final /*synthetic*/ class $anonfun$addDefaultGetters$1 extends scala.runtime.AbstractFunction0 {
    final def apply(): java.lang.String = "".+($anonfun$addDefaultGetters$1.this.meth$2.fullNameString()).+(", ").+($anonfun$addDefaultGetters$1.this.overridden$1.fullNameString());
    final /*bridge*/ def apply(): java.lang.Object = $anonfun$addDefaultGetters$1.this.apply();
    /*synthetic*/ /*paramaccessor*/ private[this] val meth$2: scala.tools.nsc.symtab.Symbol = _;
    /*synthetic*/ /*paramaccessor*/ private[this] val overridden$1: scala.tools.nsc.symtab.Symbol = _;
    def this($outer: scala.tools.nsc.typechecker.Namer, meth$2: scala.tools.nsc.symtab.Symbol, overridden$1: scala.tools.nsc.symtab.Symbol): /*anonymous class*/ $anonfun$addDefaultGetters$1 = {
      $anonfun$addDefaultGetters$1.this.meth$2 = meth$2;
      $anonfun$addDefaultGetters$1.this.overridden$1 = overridden$1;
      $anonfun$addDefaultGetters$1.super.this();
      ()
    }
  };
  @SerialVersionUID(0) @serializable 
  final /*synthetic*/ class $anonfun$apply$11 extends scala.runtime.AbstractFunction0 {
    final def apply(): java.lang.String = "".+($anonfun$apply$11.this.$outer.meth$2.fullNameString()).+(", ").+($anonfun$apply$11.this.$outer.overridden$1.fullNameString());
    /*synthetic*/ /*paramaccessor*/ private[this] val $outer: /*anonymous class*/ $anonfun$addDefaultGetters$2 = _;
    final /*bridge*/ def apply(): java.lang.Object = $anonfun$apply$11.this.apply();
    def this($outer: /*anonymous class*/ $anonfun$addDefaultGetters$2): /*anonymous class*/ $anonfun$apply$11 = {
      if ($outer.eq(null))
        throw new java.lang.NullPointerException()
      else
        $anonfun$apply$11.this.$outer = $outer;
      $anonfun$apply$11.super.this();
      ()
    }
  };
  @SerialVersionUID(0) @serializable 
  final /*synthetic*/ class $anonfun$14 extends scala.runtime.AbstractFunction1 {
    final def apply(tree: scala.tools.nsc.ast.TypeDef): scala.tools.nsc.ast.TypeDef = $anonfun$14.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$anonfun$$$outer().scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$$outer().scala$tools$nsc$typechecker$Namers$Namer$$$outer().copyUntyped(tree).$asInstanceOf[scala.tools.nsc.ast.TypeDef]();
    /*synthetic*/ /*paramaccessor*/ private[this] val $outer: /*anonymous class*/ $anonfun$apply$12 = _;
    final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = $anonfun$14.this.apply(v1.$asInstanceOf[scala.tools.nsc.ast.TypeDef]());
    def this($outer: /*anonymous class*/ $anonfun$apply$12): /*anonymous class*/ $anonfun$14 = {
      if ($outer.eq(null))
        throw new java.lang.NullPointerException()
      else
        $anonfun$14.this.$outer = $outer;
      $anonfun$14.super.this();
      ()
    }
  };
  @SerialVersionUID(0) @serializable 
  final /*synthetic*/ class $anonfun$apply$13 extends scala.runtime.AbstractFunction1 {
    final def apply(p: scala.tools.nsc.ast.ValDef): scala.tools.nsc.ast.ValDef = {
      val p1: scala.tools.nsc.ast.ValDef = $anonfun$apply$13.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$anonfun$$anonfun$$$outer().scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$anonfun$$$outer().scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$$outer().scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().atPos(p.pos().focus(), new scala.tools.nsc.ast.ValDef($anonfun$apply$13.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$anonfun$$anonfun$$$outer().scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$anonfun$$$outer().scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$$outer().scala$tools$nsc$typechecker$Namers$Namer$$$outer().global(), p.mods().&~(33554432L), p.name(), p.tpt().duplicate(), $anonfun$apply$13.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$anonfun$$anonfun$$$outer().scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$anonfun$$$outer().scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$$outer().scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().EmptyTree())).$asInstanceOf[scala.tools.nsc.ast.ValDef]();
      $anonfun$apply$13.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$anonfun$$anonfun$$$outer().scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$anonfun$$$outer().scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$$outer().scala$tools$nsc$typechecker$Namers$Namer$$$outer().UnTyper().traverse(p1);
      p1
    };
    /*synthetic*/ /*paramaccessor*/ private[this] val $outer: /*anonymous class*/ $anonfun$15 = _;
    final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = $anonfun$apply$13.this.apply(v1.$asInstanceOf[scala.tools.nsc.ast.ValDef]());
    def this($outer: /*anonymous class*/ $anonfun$15): /*anonymous class*/ $anonfun$apply$13 = {
      if ($outer.eq(null))
        throw new java.lang.NullPointerException()
      else
        $anonfun$apply$13.this.$outer = $outer;
      $anonfun$apply$13.super.this();
      ()
    }
  };
  @SerialVersionUID(0) @serializable 
  final /*synthetic*/ class $anonfun$15 extends scala.runtime.AbstractFunction1 {
    final def apply(x$24: List): List = x$24.map((new /*anonymous class*/ $anonfun$apply$13($anonfun$15.this): Function1), immutable.this.List.canBuildFrom()).$asInstanceOf[List]();
    /*synthetic*/ /*paramaccessor*/ private[this] val $outer: /*anonymous class*/ $anonfun$apply$12 = _;
    /*synthetic*/ /*stable*/ def scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$anonfun$$anonfun$$$outer(): /*anonymous class*/ $anonfun$apply$12 = $anonfun$15.this.$outer;
    final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = $anonfun$15.this.apply(v1.$asInstanceOf[List]());
    def this($outer: /*anonymous class*/ $anonfun$apply$12): /*anonymous class*/ $anonfun$15 = {
      if ($outer.eq(null))
        throw new java.lang.NullPointerException()
      else
        $anonfun$15.this.$outer = $outer;
      $anonfun$15.super.this();
      ()
    }
  };
  @SerialVersionUID(0) @serializable 
  final /*synthetic*/ class $anonfun$16 extends scala.runtime.AbstractFunction0 {
    final def apply(): Tuple2 = {
      val module: scala.tools.nsc.symtab.Symbol = $anonfun$16.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$anonfun$$$outer().meth$2.owner().linkedModuleOfClass();
      module.initialize();
      /*synthetic*/ private[this] val x$25: Tuple2 = {
        var temp147: Tuple2 = $anonfun$16.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$anonfun$$$outer().scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$$outer().scala$tools$nsc$typechecker$Namers$Namer$$$outer().classAndNamerOfModule().apply(module).$asInstanceOf[Tuple2]();
        if (temp147.ne(null))
          {
            var temp148: scala.tools.nsc.ast.ClassDef = temp147._1().$asInstanceOf[scala.tools.nsc.ast.ClassDef]();
            var temp149: scala.tools.nsc.typechecker.Namer = temp147._2().$asInstanceOf[scala.tools.nsc.typechecker.Namer]();
            {
              val nmr: scala.tools.nsc.typechecker.Namer = temp149;
              val cdef: scala.tools.nsc.ast.ClassDef = temp148;
              {
                val cdef: scala.tools.nsc.ast.ClassDef = temp148;
                val nmr: scala.tools.nsc.typechecker.Namer = temp149;
                // @todo check -- LabelDef 
                body_0: 
                /*(cdef,nmr)*/{
                  new Tuple2(cdef, nmr)
                };
                /*EmptyTree*/
              };
              /*EmptyTree*/
            };
            /*EmptyTree*/
          }
        else
          throw new MatchError(temp147.toString())
      };
      val cdef: scala.tools.nsc.ast.ClassDef = x$25._1().$asInstanceOf[scala.tools.nsc.ast.ClassDef]();
      val nmr: scala.tools.nsc.typechecker.Namer = x$25._2().$asInstanceOf[scala.tools.nsc.typechecker.Namer]();
      $anonfun$16.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$anonfun$$$outer().moduleNamer$1.elem = new Some(new Tuple2(cdef, nmr));
      new Tuple2(cdef, nmr)
    };
    /*synthetic*/ /*paramaccessor*/ private[this] val $outer: /*anonymous class*/ $anonfun$apply$12 = _;
    final /*bridge*/ def apply(): java.lang.Object = $anonfun$16.this.apply();
    def this($outer: /*anonymous class*/ $anonfun$apply$12): /*anonymous class*/ $anonfun$16 = {
      if ($outer.eq(null))
        throw new java.lang.NullPointerException()
      else
        $anonfun$16.this.$outer = $outer;
      $anonfun$16.super.this();
      ()
    }
  };
  @SerialVersionUID(0) @serializable 
  final /*synthetic*/ class $anonfun$17 extends scala.runtime.AbstractFunction1 {
    final def apply(td: scala.tools.nsc.ast.TypeDef): scala.tools.nsc.ast.TypeDef = $anonfun$17.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$anonfun$$$outer().scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$$outer().scala$tools$nsc$typechecker$Namers$Namer$$$outer().copyUntypedInvariant(td);
    /*synthetic*/ /*paramaccessor*/ private[this] val $outer: /*anonymous class*/ $anonfun$apply$12 = _;
    final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = $anonfun$17.this.apply(v1.$asInstanceOf[scala.tools.nsc.ast.TypeDef]());
    def this($outer: /*anonymous class*/ $anonfun$apply$12): /*anonymous class*/ $anonfun$17 = {
      if ($outer.eq(null))
        throw new java.lang.NullPointerException()
      else
        $anonfun$17.this.$outer = $outer;
      $anonfun$17.super.this();
      ()
    }
  };
  @SerialVersionUID(0) @serializable 
  final /*synthetic*/ class $anonfun$19 extends scala.runtime.AbstractFunction1 {
    final def apply(c: scala.tools.nsc.typechecker.Context): Boolean = c.scope().toList().contains($anonfun$19.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$anonfun$$anonfun$$$outer().scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$anonfun$$$outer().meth$2);
    /*synthetic*/ /*paramaccessor*/ private[this] val $outer: /*anonymous class*/ $anonfun$18 = _;
    final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = scala.Boolean.box($anonfun$19.this.apply(v1.$asInstanceOf[scala.tools.nsc.typechecker.Context]()));
    def this($outer: /*anonymous class*/ $anonfun$18): /*anonymous class*/ $anonfun$19 = {
      if ($outer.eq(null))
        throw new java.lang.NullPointerException()
      else
        $anonfun$19.this.$outer = $outer;
      $anonfun$19.super.this();
      ()
    }
  };
  @SerialVersionUID(0) @serializable 
  final /*synthetic*/ class $anonfun$18 extends scala.runtime.AbstractFunction0 {
    final def apply(): scala.tools.nsc.typechecker.Namer = {
      val ctx: scala.tools.nsc.typechecker.Context = $anonfun$18.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$anonfun$$$outer().scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$$outer().context().nextEnclosing((new /*anonymous class*/ $anonfun$19($anonfun$18.this): Function1));
      scala.this.Predef.assert(ctx.!=($anonfun$18.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$anonfun$$$outer().scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$$outer().scala$tools$nsc$typechecker$Namers$Namer$$$outer().NoContext()));
      val nmr: scala.tools.nsc.typechecker.Namer = $anonfun$18.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$anonfun$$$outer().scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$$outer().scala$tools$nsc$typechecker$Namers$Namer$$$outer().newNamer(ctx);
      $anonfun$18.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$anonfun$$$outer().ownerNamer$1.elem = new Some(nmr);
      nmr
    };
    /*synthetic*/ /*paramaccessor*/ private[this] val $outer: /*anonymous class*/ $anonfun$apply$12 = _;
    /*synthetic*/ /*stable*/ def scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$anonfun$$anonfun$$$outer(): /*anonymous class*/ $anonfun$apply$12 = $anonfun$18.this.$outer;
    final /*bridge*/ def apply(): java.lang.Object = $anonfun$18.this.apply();
    def this($outer: /*anonymous class*/ $anonfun$apply$12): /*anonymous class*/ $anonfun$18 = {
      if ($outer.eq(null))
        throw new java.lang.NullPointerException()
      else
        $anonfun$18.this.$outer = $outer;
      $anonfun$18.super.this();
      ()
    }
  };
  @SerialVersionUID(0) @serializable 
  final /*synthetic*/ class $anonfun$20 extends scala.runtime.AbstractFunction1 {
    final def apply(x0$2: scala.tools.nsc.ast.TypeDef): scala.tools.nsc.symtab.Name = {
      var temp153: scala.tools.nsc.ast.TypeDef = x0$2;
      if (temp153.ne(null))
        {
          var temp155: scala.tools.nsc.symtab.Name = temp153.name();
          {
            val name: scala.tools.nsc.symtab.Name = temp155;
            val name: scala.tools.nsc.symtab.Name = temp155;
            // @todo check -- LabelDef 
            body_0: 
            /*(name)*/{
              name
            };
            /*EmptyTree*/
          };
          /*EmptyTree*/
        }
      else
        throw new MatchError(temp153.toString())
    };
    final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = $anonfun$20.this.apply(v1.$asInstanceOf[scala.tools.nsc.ast.TypeDef]());
    def this($outer: /*anonymous class*/ $anonfun$apply$12): /*anonymous class*/ $anonfun$20 = {
      $anonfun$20.super.this();
      ()
    }
  };
  @SerialVersionUID(0) @serializable 
  final /*synthetic*/ class $anonfun$apply$14 extends scala.runtime.AbstractFunction1 {
    final def apply(x$27: scala.tools.nsc.ast.Tree): Boolean = x$27.isEmpty();
    final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = scala.Boolean.box($anonfun$apply$14.this.apply(v1.$asInstanceOf[scala.tools.nsc.ast.Tree]()));
    def this($outer: object scala.tools.nsc.typechecker.subst$3): /*anonymous class*/ $anonfun$apply$14 = {
      $anonfun$apply$14.super.this();
      ()
    }
  };
  final class subst$3 extends scala.tools.nsc.ast.Transformer with ScalaObject {
    override def transform(tree: scala.tools.nsc.ast.Tree): scala.tools.nsc.ast.Tree = {
      var temp158: scala.tools.nsc.ast.Tree = tree;
      if (temp158.$isInstanceOf[scala.tools.nsc.ast.Ident]())
        {
          var temp159: scala.tools.nsc.ast.Ident = temp158.$asInstanceOf[scala.tools.nsc.ast.Ident]();
          var temp160: scala.tools.nsc.symtab.Name = temp159.name();
          {
            val name: scala.tools.nsc.symtab.Name = temp160;
            if (subst$3.this.gd3$1(name))
              {
                val name: scala.tools.nsc.symtab.Name = temp160;
                // @todo check -- LabelDef 
                body_0: 
                /*(name)*/{
                  new scala.tools.nsc.ast.TypeTree(subst$3.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$anonfun$$$outer().scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$$outer().scala$tools$nsc$typechecker$Namers$Namer$$$outer().global())
                }
              }
            else
              // @todo check -- LabelDef 
              body_1: 
              /*()*/{
                subst$3.super.transform(tree)
              }
          };
          /*EmptyTree*/
        }
      else
         () // @todo -- goto body_1 /* vargs ()*/
        
    };
    def apply(tree: scala.tools.nsc.ast.Tree): scala.tools.nsc.ast.Tree = {
      val r: scala.tools.nsc.ast.Tree = subst$3.this.transform(tree);
      if (r.exists((new /*anonymous class*/ $anonfun$apply$14(subst$3.this): Function1)))
        new scala.tools.nsc.ast.TypeTree(subst$3.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$anonfun$$$outer().scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$$outer().scala$tools$nsc$typechecker$Namers$Namer$$$outer().global())
      else
        r
    };
    /*synthetic*/ /*paramaccessor*/ private[this] val $outer: /*anonymous class*/ $anonfun$apply$12 = _;
    /*synthetic*/ /*paramaccessor*/ private[this] val names$1: List = _;
    final /*synthetic*/ private[this] def gd3$1(x$1: scala.tools.nsc.symtab.Name): Boolean = subst$3.this.names$1.contains(x$1);
    def this($outer: /*anonymous class*/ $anonfun$apply$12, names$1: List): object scala.tools.nsc.typechecker.subst$3 = {
      if ($outer.eq(null))
        throw new java.lang.NullPointerException()
      else
        subst$3.this.$outer = $outer;
      subst$3.this.names$1 = names$1;
      subst$3.super.this($outer.scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$anonfun$$$outer().scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$$outer().scala$tools$nsc$typechecker$Namers$Namer$$$outer().global());
      ()
    }
  };
  @SerialVersionUID(0) @serializable 
  final /*synthetic*/ class $anonfun$apply$12 extends scala.runtime.AbstractFunction1 {
    final def apply(vparam: scala.tools.nsc.ast.ValDef): Unit = {
      val sym$6: scala.tools.nsc.symtab.Symbol = vparam.symbol();
      val baseHasDefault: Boolean = $anonfun$apply$12.this.$outer.overrides$1.&&($anonfun$apply$12.this.baseParams$1.elem.$asInstanceOf[List]().head().$asInstanceOf[scala.tools.nsc.symtab.Symbol]().hasFlag(33554432L));
      if (sym$6.hasFlag(33554432L))
        {
          val oflag: Int = if (baseHasDefault)
            2
          else
            0;
          val name: java.lang.String = scala.this.Predef.any2stringadd(if ($anonfun$apply$12.this.$outer.isConstr$1)
            "init"
          else
            $anonfun$apply$12.this.$outer.meth$2.name()).+("$default$").+(scala.Int.box($anonfun$apply$12.this.$outer.posCounter$1.elem));
          var deftParams: List = $anonfun$apply$12.this.$outer.tparams$4.map((new /*anonymous class*/ $anonfun$14($anonfun$apply$12.this): Function1), immutable.this.List.canBuildFrom()).$asInstanceOf[List]();
          val defvParamss: List = $anonfun$apply$12.this.previous$1.map((new /*anonymous class*/ $anonfun$15($anonfun$apply$12.this): Function1), immutable.this.List.canBuildFrom()).$asInstanceOf[List]();
          val parentNamer: scala.tools.nsc.typechecker.Namer = if ($anonfun$apply$12.this.$outer.isConstr$1)
            {
              /*synthetic*/ private[this] val x$26: Tuple2 = {
                var temp150: Tuple2 = $anonfun$apply$12.this.$outer.moduleNamer$1.elem.$asInstanceOf[Option]().getOrElse((new /*anonymous class*/ $anonfun$16($anonfun$apply$12.this): Function0)).$asInstanceOf[Tuple2]();
                if (temp150.ne(null))
                  {
                    var temp151: scala.tools.nsc.ast.ClassDef = temp150._1().$asInstanceOf[scala.tools.nsc.ast.ClassDef]();
                    var temp152: scala.tools.nsc.typechecker.Namer = temp150._2().$asInstanceOf[scala.tools.nsc.typechecker.Namer]();
                    {
                      val nmr: scala.tools.nsc.typechecker.Namer = temp152;
                      val cdef: scala.tools.nsc.ast.ClassDef = temp151;
                      {
                        val cdef: scala.tools.nsc.ast.ClassDef = temp151;
                        val nmr: scala.tools.nsc.typechecker.Namer = temp152;
                        // @todo check -- LabelDef 
                        body_0: 
                        /*(cdef,nmr)*/{
                          new Tuple2(cdef, nmr)
                        };
                        /*EmptyTree*/
                      };
                      /*EmptyTree*/
                    };
                    /*EmptyTree*/
                  }
                else
                  throw new MatchError(temp150.toString())
              };
              val cdef: scala.tools.nsc.ast.ClassDef = x$26._1().$asInstanceOf[scala.tools.nsc.ast.ClassDef]();
              val nmr: scala.tools.nsc.typechecker.Namer = x$26._2().$asInstanceOf[scala.tools.nsc.typechecker.Namer]();
              deftParams = cdef.tparams().map((new /*anonymous class*/ $anonfun$17($anonfun$apply$12.this): Function1), immutable.this.List.canBuildFrom()).$asInstanceOf[List]();
              nmr
            }
          else
            $anonfun$apply$12.this.$outer.ownerNamer$1.elem.$asInstanceOf[Option]().getOrElse((new /*anonymous class*/ $anonfun$18($anonfun$apply$12.this): Function0)).$asInstanceOf[scala.tools.nsc.typechecker.Namer]();
          val names$1: List = deftParams.map((new /*anonymous class*/ $anonfun$20($anonfun$apply$12.this): Function1), immutable.this.List.canBuildFrom()).$asInstanceOf[List]();
          var subst$module$1: scala.runtime.ObjectRef = new scala.runtime.ObjectRef(null);
          val defTpt: scala.tools.nsc.ast.Tree = $anonfun$apply$12.this.subst$2(names$1, subst$module$1).apply($anonfun$apply$12.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$$outer().scala$tools$nsc$typechecker$Namers$Namer$$$outer().copyUntyped({
            var temp161: scala.tools.nsc.ast.Tree = vparam.tpt();
            if (temp161.$isInstanceOf[scala.tools.nsc.ast.AppliedTypeTree]())
              {
                var temp162: scala.tools.nsc.ast.AppliedTypeTree = temp161.$asInstanceOf[scala.tools.nsc.ast.AppliedTypeTree]();
                {
                  var temp164: List = temp162.args();
                  if (temp164.$isInstanceOf[scala.collection.immutable.::]())
                    {
                      var temp165: scala.collection.immutable.:: = temp164.$asInstanceOf[scala.collection.immutable.::]();
                      var temp166: scala.tools.nsc.ast.Tree = temp165.hd$1().$asInstanceOf[scala.tools.nsc.ast.Tree]();
                      if (immutable.this.Nil.==(temp165.tl$1()))
                        {
                          val arg: scala.tools.nsc.ast.Tree = temp166;
                          if ($anonfun$apply$12.this.gd4$1(arg, sym$6))
                            {
                              val arg: scala.tools.nsc.ast.Tree = temp166;
                              // @todo check -- LabelDef 
                              body_0: 
                              /*(arg)*/{
                                arg
                              }
                            }
                          else
                            {
                              val t: scala.tools.nsc.ast.Tree = temp162;
                              val t: scala.tools.nsc.ast.Tree = temp162;
                              // @todo check -- LabelDef 
                              body_1: 
                              /*(t)*/{
                                t
                              };
                              /*EmptyTree*/
                            }
                        }
                      else
                         () // @todo -- goto body_1 /* vargs (temp162)*/
                        ;
                      /*EmptyTree*/
                    }
                  else
                     () // @todo -- goto body_1 /* vargs (temp162)*/
                    
                };
                /*EmptyTree*/
              }
            else
               () // @todo -- goto body_1 /* vargs (temp161)*/
              
          }));
          val defRhs: scala.tools.nsc.ast.Tree = $anonfun$apply$12.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$$outer().scala$tools$nsc$typechecker$Namers$Namer$$$outer().copyUntyped(vparam.rhs());
          val defaultTree: scala.tools.nsc.ast.DefDef = $anonfun$apply$12.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$$outer().scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().atPos(vparam.pos().focus(), new scala.tools.nsc.ast.DefDef($anonfun$apply$12.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$$outer().scala$tools$nsc$typechecker$Namers$Namer$$$outer().global(), $anonfun$apply$12.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$$outer().scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().Modifiers($anonfun$apply$12.this.$outer.meth$2.flags().&(37)).|(2097152L).|(33554432L).|(oflag.toLong()), $anonfun$apply$12.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$$outer().scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().view(name), deftParams, defvParamss, defTpt, defRhs)).$asInstanceOf[scala.tools.nsc.ast.DefDef]();
          $anonfun$apply$12.this.$outer.meth$2.owner().resetFlag(128L);
          val default: scala.tools.nsc.symtab.Symbol = parentNamer.enterSyntheticSym(defaultTree);
          sym$6.defaultGetter_=(default)
        }
      else
        if (baseHasDefault)
          {
            sym$6.setFlag(33554432L);
            sym$6.defaultGetter_=($anonfun$apply$12.this.baseParams$1.elem.$asInstanceOf[List]().head().$asInstanceOf[scala.tools.nsc.symtab.Symbol]().defaultGetter())
          }
        else
          ();
      $anonfun$apply$12.this.$outer.posCounter$1.elem = $anonfun$apply$12.this.$outer.posCounter$1.elem.+(1);
      if ($anonfun$apply$12.this.$outer.overrides$1)
        $anonfun$apply$12.this.baseParams$1.elem = $anonfun$apply$12.this.baseParams$1.elem.$asInstanceOf[List]().tail().$asInstanceOf[List]()
      else
        ()
    };
    /*synthetic*/ /*paramaccessor*/ private[this] val $outer: /*anonymous class*/ $anonfun$addDefaultGetters$2 = _;
    /*synthetic*/ /*stable*/ def scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$anonfun$$$outer(): /*anonymous class*/ $anonfun$addDefaultGetters$2 = $anonfun$apply$12.this.$outer;
    final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = {
      $anonfun$apply$12.this.apply(v1.$asInstanceOf[scala.tools.nsc.ast.ValDef]());
      scala.runtime.BoxedUnit.UNIT
    };
    /*synthetic*/ /*paramaccessor*/ private[this] val previous$1: List = _;
    /*synthetic*/ /*paramaccessor*/ private[this] val baseParams$1: scala.runtime.ObjectRef = _;
    final /*stable*/ private[this] def subst$2(names$1: List, subst$module$1: scala.runtime.ObjectRef): object scala.tools.nsc.typechecker.subst$3 = {
      if (subst$module$1.elem.$asInstanceOf[object scala.tools.nsc.typechecker.subst$3]().eq(null))
        subst$module$1.elem = new object scala.tools.nsc.typechecker.subst$3($anonfun$apply$12.this, names$1);
      subst$module$1.elem.$asInstanceOf[object scala.tools.nsc.typechecker.subst$3]()
    };
    final /*synthetic*/ private[this] def gd4$1(x$1: scala.tools.nsc.ast.Tree, sym$6: scala.tools.nsc.symtab.Symbol): Boolean = sym$6.hasFlag(65536L);
    def this($outer: /*anonymous class*/ $anonfun$addDefaultGetters$2, previous$1: List, baseParams$1: scala.runtime.ObjectRef): /*anonymous class*/ $anonfun$apply$12 = {
      if ($outer.eq(null))
        throw new java.lang.NullPointerException()
      else
        $anonfun$apply$12.this.$outer = $outer;
      $anonfun$apply$12.this.previous$1 = previous$1;
      $anonfun$apply$12.this.baseParams$1 = baseParams$1;
      $anonfun$apply$12.super.this();
      ()
    }
  };
  @SerialVersionUID(0) @serializable 
  final /*synthetic*/ class $anonfun$addDefaultGetters$2 extends scala.runtime.AbstractFunction2 {
    final def apply(previous$1: List, vparams: List): List = {
      scala.this.Predef.assert($anonfun$addDefaultGetters$2.this.overrides$1.unary_!().||(vparams.length().==($anonfun$addDefaultGetters$2.this.baseParamss$1.elem.$asInstanceOf[List]().head().$asInstanceOf[scala.collection.LinearSeqLike]().length())), (new /*anonymous class*/ $anonfun$apply$11($anonfun$addDefaultGetters$2.this): Function0));
      var baseParams$1: scala.runtime.ObjectRef = new scala.runtime.ObjectRef(if ($anonfun$addDefaultGetters$2.this.overrides$1)
        $anonfun$addDefaultGetters$2.this.baseParamss$1.elem.$asInstanceOf[List]().head().$asInstanceOf[List]()
      else
        immutable.this.Nil);
      vparams.foreach((new /*anonymous class*/ $anonfun$apply$12($anonfun$addDefaultGetters$2.this, previous$1, baseParams$1): Function1));
      if ($anonfun$addDefaultGetters$2.this.overrides$1)
        $anonfun$addDefaultGetters$2.this.baseParamss$1.elem = $anonfun$addDefaultGetters$2.this.baseParamss$1.elem.$asInstanceOf[List]().tail().$asInstanceOf[List]()
      else
        ();
      /*synthetic*/ val x$28: List = previous$1;
      immutable.this.List.apply(scala.this.Predef.wrapRefArray(Array[List]{vparams}.$asInstanceOf[Array[java.lang.Object]]())).:::(x$28);
      /*EmptyTree*/
    };
    /*synthetic*/ /*paramaccessor*/ private[this] val $outer: scala.tools.nsc.typechecker.Namer = _;
    /*synthetic*/ /*stable*/ def scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$$outer(): scala.tools.nsc.typechecker.Namer = $anonfun$addDefaultGetters$2.this.$outer;
    final /*bridge*/ def apply(v1: java.lang.Object, v2: java.lang.Object): java.lang.Object = $anonfun$addDefaultGetters$2.this.apply(v1.$asInstanceOf[List](), v2.$asInstanceOf[List]());
    /*synthetic*/ /*paramaccessor*/ val meth$2: scala.tools.nsc.symtab.Symbol = _;
    /*synthetic*/ /*paramaccessor*/ val tparams$4: List = _;
    /*synthetic*/ /*paramaccessor*/ val isConstr$1: Boolean = _;
    /*synthetic*/ /*paramaccessor*/ val overridden$1: scala.tools.nsc.symtab.Symbol = _;
    /*synthetic*/ /*paramaccessor*/ val overrides$1: Boolean = _;
    /*synthetic*/ /*paramaccessor*/ private[this] val baseParamss$1: scala.runtime.ObjectRef = _;
    /*synthetic*/ /*paramaccessor*/ val ownerNamer$1: scala.runtime.ObjectRef = _;
    /*synthetic*/ /*paramaccessor*/ val moduleNamer$1: scala.runtime.ObjectRef = _;
    /*synthetic*/ /*paramaccessor*/ val posCounter$1: scala.runtime.IntRef = _;
    def this($outer: scala.tools.nsc.typechecker.Namer, meth$2: scala.tools.nsc.symtab.Symbol, tparams$4: List, isConstr$1: Boolean, overridden$1: scala.tools.nsc.symtab.Symbol, overrides$1: Boolean, baseParamss$1: scala.runtime.ObjectRef, ownerNamer$1: scala.runtime.ObjectRef, moduleNamer$1: scala.runtime.ObjectRef, posCounter$1: scala.runtime.IntRef): /*anonymous class*/ $anonfun$addDefaultGetters$2 = {
      if ($outer.eq(null))
        throw new java.lang.NullPointerException()
      else
        $anonfun$addDefaultGetters$2.this.$outer = $outer;
      $anonfun$addDefaultGetters$2.this.meth$2 = meth$2;
      $anonfun$addDefaultGetters$2.this.tparams$4 = tparams$4;
      $anonfun$addDefaultGetters$2.this.isConstr$1 = isConstr$1;
      $anonfun$addDefaultGetters$2.this.overridden$1 = overridden$1;
      $anonfun$addDefaultGetters$2.this.overrides$1 = overrides$1;
      $anonfun$addDefaultGetters$2.this.baseParamss$1 = baseParamss$1;
      $anonfun$addDefaultGetters$2.this.ownerNamer$1 = ownerNamer$1;
      $anonfun$addDefaultGetters$2.this.moduleNamer$1 = moduleNamer$1;
      $anonfun$addDefaultGetters$2.this.posCounter$1 = posCounter$1;
      $anonfun$addDefaultGetters$2.super.this();
      ()
    }
  };
  @SerialVersionUID(0) @serializable 
  final /*synthetic*/ class $anonfun$typeDefSig$1 extends scala.runtime.AbstractFunction1 {
    final def apply(x$29: scala.tools.nsc.symtab.Symbol): Boolean = $anonfun$typeDefSig$1.this.$outer.verifyOverriding$1(x$29, $anonfun$typeDefSig$1.this.tpsym$1, $anonfun$typeDefSig$1.this.tparamSyms$2);
    /*synthetic*/ /*paramaccessor*/ private[this] val $outer: scala.tools.nsc.typechecker.Namer = _;
    final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = scala.Boolean.box($anonfun$typeDefSig$1.this.apply(v1.$asInstanceOf[scala.tools.nsc.symtab.Symbol]()));
    /*synthetic*/ /*paramaccessor*/ private[this] val tpsym$1: scala.tools.nsc.symtab.Symbol = _;
    /*synthetic*/ /*paramaccessor*/ private[this] val tparamSyms$2: List = _;
    def this($outer: scala.tools.nsc.typechecker.Namer, tpsym$1: scala.tools.nsc.symtab.Symbol, tparamSyms$2: List): /*anonymous class*/ $anonfun$typeDefSig$1 = {
      if ($outer.eq(null))
        throw new java.lang.NullPointerException()
      else
        $anonfun$typeDefSig$1.this.$outer = $outer;
      $anonfun$typeDefSig$1.this.tpsym$1 = tpsym$1;
      $anonfun$typeDefSig$1.this.tparamSyms$2 = tparamSyms$2;
      $anonfun$typeDefSig$1.super.this();
      ()
    }
  };
  @SerialVersionUID(0) @serializable 
  final /*synthetic*/ class $anonfun$addCopyMethod$1 extends scala.runtime.AbstractFunction1 {
    final def apply(x$30: scala.tools.nsc.ast.DefDef): scala.tools.nsc.symtab.Symbol = $anonfun$addCopyMethod$1.this.namer$2.enterSyntheticSym(x$30);
    final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = $anonfun$addCopyMethod$1.this.apply(v1.$asInstanceOf[scala.tools.nsc.ast.DefDef]());
    /*synthetic*/ /*paramaccessor*/ private[this] val namer$2: scala.tools.nsc.typechecker.Namer = _;
    def this($outer: scala.tools.nsc.typechecker.Namer, namer$2: scala.tools.nsc.typechecker.Namer): /*anonymous class*/ $anonfun$addCopyMethod$1 = {
      $anonfun$addCopyMethod$1.this.namer$2 = namer$2;
      $anonfun$addCopyMethod$1.super.this();
      ()
    }
  };
  @SerialVersionUID(0) @serializable 
  final /*synthetic*/ class $anonfun$21 extends scala.runtime.AbstractFunction1 {
    final def apply(x$31: scala.tools.nsc.ast.Tree): Boolean = x$31.!=(null);
    final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = scala.Boolean.box($anonfun$21.this.apply(v1.$asInstanceOf[scala.tools.nsc.ast.Tree]()));
    def this($outer: scala.tools.nsc.typechecker.Namer): /*anonymous class*/ $anonfun$21 = {
      $anonfun$21.super.this();
      ()
    }
  };
  @SerialVersionUID(0) @serializable 
  final /*synthetic*/ class $anonfun$apply$15 extends scala.runtime.AbstractFunction0 {
    final def apply(): scala.tools.nsc.symtab.AnnotationInfo = $anonfun$apply$15.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$$outer().typer().typedAnnotation($anonfun$apply$15.this.ann$1, $anonfun$apply$15.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$$outer().typer().typedAnnotation$default$2(), $anonfun$apply$15.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$$outer().typer().typedAnnotation$default$3(), $anonfun$apply$15.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$$outer().typer().typedAnnotation$default$4(), $anonfun$apply$15.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$$outer().typer().typedAnnotation$default$5());
    /*synthetic*/ /*paramaccessor*/ private[this] val $outer: /*anonymous class*/ $anonfun$22 = _;
    final /*bridge*/ def apply(): java.lang.Object = $anonfun$apply$15.this.apply();
    /*synthetic*/ /*paramaccessor*/ private[this] val ann$1: scala.tools.nsc.ast.Tree = _;
    def this($outer: /*anonymous class*/ $anonfun$22, ann$1: scala.tools.nsc.ast.Tree): /*anonymous class*/ $anonfun$apply$15 = {
      if ($outer.eq(null))
        throw new java.lang.NullPointerException()
      else
        $anonfun$apply$15.this.$outer = $outer;
      $anonfun$apply$15.this.ann$1 = ann$1;
      $anonfun$apply$15.super.this();
      ()
    }
  };
  @SerialVersionUID(0) @serializable 
  final /*synthetic*/ class $anonfun$22 extends scala.runtime.AbstractFunction1 {
    final def apply(ann$1: scala.tools.nsc.ast.Tree): scala.tools.nsc.symtab.LazyAnnotationInfo = new scala.tools.nsc.symtab.LazyAnnotationInfo($anonfun$22.this.$outer.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global(), (new /*anonymous class*/ $anonfun$apply$15($anonfun$22.this, ann$1): Function0));
    /*synthetic*/ /*paramaccessor*/ private[this] val $outer: scala.tools.nsc.typechecker.Namer = _;
    /*synthetic*/ /*stable*/ def scala$tools$nsc$typechecker$Namers$Namer$$anonfun$$$outer(): scala.tools.nsc.typechecker.Namer = $anonfun$22.this.$outer;
    final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = $anonfun$22.this.apply(v1.$asInstanceOf[scala.tools.nsc.ast.Tree]());
    def this($outer: scala.tools.nsc.typechecker.Namer): /*anonymous class*/ $anonfun$22 = {
      if ($outer.eq(null))
        throw new java.lang.NullPointerException()
      else
        $anonfun$22.this.$outer = $outer;
      $anonfun$22.super.this();
      ()
    }
  };
  @SerialVersionUID(0) @serializable 
  final /*synthetic*/ class $anonfun$23 extends scala.runtime.AbstractFunction1 {
    final def apply(sym: scala.tools.nsc.symtab.Symbol): Boolean = sym.exists().&&($anonfun$23.this.$outer.context().isAccessible(sym, $anonfun$23.this.$outer.context().prefix(), false));
    /*synthetic*/ /*paramaccessor*/ private[this] val $outer: scala.tools.nsc.typechecker.Namer = _;
    final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = scala.Boolean.box($anonfun$23.this.apply(v1.$asInstanceOf[scala.tools.nsc.symtab.Symbol]()));
    def this($outer: scala.tools.nsc.typechecker.Namer): /*anonymous class*/ $anonfun$23 = {
      if ($outer.eq(null))
        throw new java.lang.NullPointerException()
      else
        $anonfun$23.this.$outer = $outer;
      $anonfun$23.super.this();
      ()
    }
  };
  @SerialVersionUID(0) @serializable 
  final /*synthetic*/ class $anonfun$checkSelectors$1$1 extends scala.runtime.AbstractFunction1 {
    final def apply(sel: scala.tools.nsc.ast.ImportSelector): Boolean = sel.name().==($anonfun$checkSelectors$1$1.this.from$1);
    final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = scala.Boolean.box($anonfun$checkSelectors$1$1.this.apply(v1.$asInstanceOf[scala.tools.nsc.ast.ImportSelector]()));
    /*synthetic*/ /*paramaccessor*/ private[this] val from$1: scala.tools.nsc.symtab.Name = _;
    def this($outer: scala.tools.nsc.typechecker.Namer, from$1: scala.tools.nsc.symtab.Name): /*anonymous class*/ $anonfun$checkSelectors$1$1 = {
      $anonfun$checkSelectors$1$1.this.from$1 = from$1;
      $anonfun$checkSelectors$1$1.super.this();
      ()
    }
  };
  @SerialVersionUID(0) @serializable 
  final /*synthetic*/ class $anonfun$checkSelectors$1$2 extends scala.runtime.AbstractFunction1 {
    final def apply(sel: scala.tools.nsc.ast.ImportSelector): Boolean = sel.rename().==($anonfun$checkSelectors$1$2.this.to$2);
    final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = scala.Boolean.box($anonfun$checkSelectors$1$2.this.apply(v1.$asInstanceOf[scala.tools.nsc.ast.ImportSelector]()));
    /*synthetic*/ /*paramaccessor*/ private[this] val to$2: scala.tools.nsc.symtab.Name = _;
    def this($outer: scala.tools.nsc.typechecker.Namer, to$2: scala.tools.nsc.symtab.Name): /*anonymous class*/ $anonfun$checkSelectors$1$2 = {
      $anonfun$checkSelectors$1$2.this.to$2 = to$2;
      $anonfun$checkSelectors$1$2.super.this();
      ()
    }
  };
  @SerialVersionUID(0) @serializable 
  final /*synthetic*/ class $anonfun$gd7$1$1 extends scala.runtime.AbstractFunction1 {
    final def apply(x$32: scala.tools.nsc.symtab.Symbol): Boolean = x$32.typeParams().isEmpty().unary_!();
    final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = scala.Boolean.box($anonfun$gd7$1$1.this.apply(v1.$asInstanceOf[scala.tools.nsc.symtab.Symbol]()));
    def this($outer: scala.tools.nsc.typechecker.Namer): /*anonymous class*/ $anonfun$gd7$1$1 = {
      $anonfun$gd7$1$1.super.this();
      ()
    }
  };
  abstract class Namer extends java.lang.Object with ScalaObject {
    /*paramaccessor*/ private[this] val context: scala.tools.nsc.typechecker.Context = _;
    /*stable*/ /*accessor*/ /*paramaccessor*/ def context(): scala.tools.nsc.typechecker.Context = Namer.this.context;
    private[this] val typer: scala.tools.nsc.typechecker.Typer = _;
    /*stable*/ /*accessor*/ def typer(): scala.tools.nsc.typechecker.Typer = Namer.this.typer;
    def setPrivateWithin(tree: scala.tools.nsc.ast.Tree, sym: scala.tools.nsc.symtab.Symbol, mods: scala.tools.nsc.ast.Modifiers): scala.tools.nsc.symtab.Symbol = {
      if (mods.privateWithin().isEmpty().unary_!())
        sym.privateWithin_=(Namer.this.typer().qualifyingClass(tree, mods.privateWithin(), true))
      else
        ();
      sym
    };
    def inConstructorFlag(): Long = if (Namer.this.context().owner().isConstructor().&&(Namer.this.context().inConstructorSuffix().unary_!()).||(Namer.this.context().owner().isEarly()))
      131072L
    else
      0L;
    def moduleClassFlags(moduleFlags: Long): Long = moduleFlags.&(symtab.Flags.ModuleToClassFlags()).|(32).|(Namer.this.inConstructorFlag());
    def updatePosFlags(sym: scala.tools.nsc.symtab.Symbol, pos: scala.tools.nsc.util.Position, flags: Long): scala.tools.nsc.symtab.Symbol = {
      if (scala.Boolean.unbox(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().settings().debug().value()))
        Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().log("overwriting ".+(sym))
      else
        ();
      val lockedFlag: Long = sym.flags().&(549755813888L);
      sym.reset(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().NoType());
      sym.setPos(pos);
      sym.flags_=(flags.|(lockedFlag));
      if (sym.isModule().&&(sym.moduleClass().!=(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().NoSymbol())))
        Namer.this.updatePosFlags(sym.moduleClass(), pos, Namer.this.moduleClassFlags(flags))
      else
        scala.runtime.BoxedUnit.UNIT;
      if (sym.owner().isPackageClass().&&(sym.linkedSym().rawInfo().$isInstanceOf[scala.tools.nsc.symtab.SymbolLoader]().||(sym.linkedSym().rawInfo().isComplete().&&(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().runId(sym.validTo()).!=(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().currentRunId())))))
        sym.linkedSym().setInfo(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().NoType())
      else
        scala.runtime.BoxedUnit.UNIT;
      sym
    };
    private def isTemplateContext(context: scala.tools.nsc.typechecker.Context): Boolean = {
      /*synthetic*/ val _$this: scala.tools.nsc.typechecker.Namer = Namer.this;
      do
        var temp6: scala.tools.nsc.ast.Tree = context.tree()
      while (temp6.$isInstanceOf[scala.tools.nsc.ast.Template]())
      
    };
    private[this] var innerNamerCache: scala.tools.nsc.typechecker.Namer = _;
    private /*accessor*/ def innerNamerCache(): scala.tools.nsc.typechecker.Namer = Namer.this.innerNamerCache;
    private /*accessor*/ def innerNamerCache_=(x$1: scala.tools.nsc.typechecker.Namer): Unit = Namer.this.innerNamerCache = x$1;
    protected def makeConstructorScope(classContext: scala.tools.nsc.typechecker.Context): scala.tools.nsc.typechecker.Context = {
      val outerContext: scala.tools.nsc.typechecker.Context = classContext.outer().outer();
      outerContext.makeNewScope(outerContext.tree(), outerContext.owner())
    };
    def namerOf(sym$1: scala.tools.nsc.symtab.Symbol): scala.tools.nsc.typechecker.Namer = if (Namer.this.usePrimary$1(sym$1))
      Namer.this.primaryConstructorParamNamer$1()
    else
      Namer.this.innerNamer$1();
    protected def conflict(newS: scala.tools.nsc.symtab.Symbol, oldS: scala.tools.nsc.symtab.Symbol): Boolean = oldS.isSourceMethod().unary_!().||(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().nme().isSetterName(newS.name())).||(newS.owner().isPackageClass()).&&(newS.owner().isTypeParameter().||(newS.owner().isAbstractType()).&&(newS.name().length().==(1)).&&(newS.name().apply(0).==('_')).unary_!());
    protected def setInfo(sym: scala.tools.nsc.symtab.Symbol, tpe: scala.tools.nsc.symtab.LazyType): scala.tools.nsc.symtab.Symbol = sym.setInfo(tpe);
    private def doubleDefError(pos: scala.tools.nsc.util.Position, sym: scala.tools.nsc.symtab.Symbol): Unit = Namer.this.context().error(pos, sym.name().toString().+(" is already defined as ").+(if (sym.hasFlag(2097152L))
      "(compiler-generated) ".+(if (sym.isModule())
        "case class companion "
      else
        "")
    else
      "").+(if (sym.hasFlag(2048L))
      "case class ".+(sym.name())
    else
      sym.toString()));
    private def inCurrentScope(m: scala.tools.nsc.symtab.Symbol): Boolean = if (Namer.this.context().owner().isClass())
      Namer.this.context().owner().==(m.owner())
    else
      m.owner().isClass().&&(Namer.this.context().scope().==(m.owner().info().decls()));
    def enterInScope(sym: scala.tools.nsc.symtab.Symbol): scala.tools.nsc.symtab.Symbol = Namer.this.enterInScope(sym, Namer.this.context().scope());
    def enterInScope(sym: scala.tools.nsc.symtab.Symbol, scope: scala.tools.nsc.symtab.Scope): scala.tools.nsc.symtab.Symbol = if (sym.isSourceMethod().&&(sym.owner().isClass()).&&(sym.owner().isPackageClass().unary_!()).unary_!())
      {
        var prev: scala.tools.nsc.symtab.ScopeEntry = scope.lookupEntry(sym.name());
        if (prev.ne(null).&&(prev.owner().==(scope)).&&(Namer.this.conflict(sym, prev.sym())))
          {
            Namer.this.doubleDefError(sym.pos(), prev.sym());
            sym.setInfo(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().ErrorType());
            scope.unlink(prev.sym());
            scope.enter(sym)
          }
        else
          scope.enter(sym)
      }
    else
      scope.enter(sym);
    def enterPackageSymbol(pos: scala.tools.nsc.util.Position, pid: scala.tools.nsc.ast.RefTree, pkgOwner: scala.tools.nsc.symtab.Symbol): scala.tools.nsc.symtab.Symbol = {
      val owner: scala.tools.nsc.symtab.Symbol = {
        var temp14: scala.tools.nsc.ast.RefTree = pid;
        if (temp14.$isInstanceOf[scala.tools.nsc.ast.Ident]())
          {
            var temp15: scala.tools.nsc.ast.Ident = temp14.$asInstanceOf[scala.tools.nsc.ast.Ident]();
            var temp16: scala.tools.nsc.symtab.Name = temp15.name();
            {
              val name: scala.tools.nsc.symtab.Name = temp16;
              val name: scala.tools.nsc.symtab.Name = temp16;
              // @todo check -- LabelDef 
              body_0: 
              /*(name)*/{
                pkgOwner
              };
              /*EmptyTree*/
            };
            /*EmptyTree*/
          }
        else
          if (temp14.$isInstanceOf[scala.tools.nsc.ast.Select]())
            {
              var temp17: scala.tools.nsc.ast.Select = temp14.$asInstanceOf[scala.tools.nsc.ast.Select]();
              var temp18: scala.tools.nsc.ast.Tree = temp17.qualifier();
              {
                var temp19: scala.tools.nsc.symtab.Name = temp17.name();
                if (temp18.$isInstanceOf[scala.tools.nsc.ast.RefTree]())
                  {
                    var temp20: scala.tools.nsc.ast.RefTree = temp18.$asInstanceOf[scala.tools.nsc.ast.RefTree]();
                    {
                      val name: scala.tools.nsc.symtab.Name = temp19;
                      val qual: scala.tools.nsc.ast.RefTree = temp20;
                      {
                        val qual: scala.tools.nsc.ast.RefTree = temp20;
                        val name: scala.tools.nsc.symtab.Name = temp19;
                        // @todo check -- LabelDef 
                        body_1: 
                        /*(qual,name)*/{
                          Namer.this.enterPackageSymbol(pos, qual, pkgOwner).moduleClass()
                        };
                        /*EmptyTree*/
                      };
                      /*EmptyTree*/
                    };
                    /*EmptyTree*/
                  }
                else
                  throw new MatchError(temp14.$asInstanceOf[scala.tools.nsc.ast.Tree]().toString())
              };
              /*EmptyTree*/
            }
          else
            throw new MatchError(temp14.$asInstanceOf[scala.tools.nsc.ast.Tree]().toString())
      };
      var pkg: scala.tools.nsc.symtab.Symbol = owner.info().decls().lookup(pid.name());
      if (pkg.isPackage().unary_!().||(owner.!=(pkg.owner())))
        {
          pkg = owner.newPackage(pos, pid.name());
          pkg.moduleClass().setInfo(new scala.tools.nsc.symtab.PackageClassInfoType(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global(), new scala.tools.nsc.symtab.Scope(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global()), pkg.moduleClass()));
          pkg.setInfo(pkg.moduleClass().tpe());
          Namer.this.enterInScope(pkg, owner.info().decls())
        }
      else
        scala.runtime.BoxedUnit.UNIT;
      pkg
    };
    def enterClassSymbol(tree: scala.tools.nsc.ast.ClassDef): scala.tools.nsc.symtab.Symbol = {
      var c: scala.tools.nsc.symtab.Symbol = Namer.this.context().scope().lookup(tree.name());
      if (c.isType().&&(c.owner().isPackageClass()).&&(Namer.this.context().scope().==(c.owner().info().decls())).&&(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().currentRun().compiles(c).unary_!()))
        {
          Namer.this.updatePosFlags(c, tree.pos(), tree.mods().flags());
          Namer.this.setPrivateWithin(tree, c, tree.mods())
        }
      else
        {
          var sym: scala.tools.nsc.symtab.ClassSymbol = Namer.this.context().owner().newClass(tree.pos(), tree.name());
          sym = sym.setFlag(tree.mods().flags().|(Namer.this.inConstructorFlag())).$asInstanceOf[scala.tools.nsc.symtab.ClassSymbol]();
          sym = Namer.this.setPrivateWithin(tree, sym, tree.mods()).$asInstanceOf[scala.tools.nsc.symtab.ClassSymbol]();
          c = Namer.this.enterInScope(sym);
          scala.runtime.BoxedUnit.UNIT
        };
      if (c.owner().isPackageClass())
        {
          val file: scala.tools.nsc.io.AbstractFile = Namer.this.context().unit().source().file();
          val clazz: scala.tools.nsc.symtab.ClassSymbol = c.$asInstanceOf[scala.tools.nsc.symtab.ClassSymbol]();
          if (scala.Boolean.unbox(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().settings().debug().value()).&&(clazz.sourceFile().ne(null)).&&(clazz.sourceFile().equals(file).unary_!()))
            scala.Console.err().println("SOURCE MISMATCH: ".+(clazz.sourceFile()).+(" vs. ").+(file).+(" SYM=").+(c))
          else
            ();
          clazz.sourceFile_=(file);
          if (clazz.sourceFile().ne(null))
            {
              scala.this.Predef.assert(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().currentRun().compiles(clazz).unary_!().||(clazz.sourceFile().==(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().currentRun().symSource().apply(c))));
              Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().currentRun().symSource().update(c, clazz.sourceFile())
            }
          else
            ()
        }
      else
        ();
      scala.this.Predef.assert(c.name().toString().indexOf(40).==(-1));
      c
    };
    def enterModuleSymbol(tree: scala.tools.nsc.ast.ModuleDef): scala.tools.nsc.symtab.Symbol = {
      var m: scala.tools.nsc.symtab.Symbol = Namer.this.context().scope().lookup(tree.name());
      val moduleFlags: Long = tree.mods().flags().|(256).|(32);
      if (m.isModule().&&(m.isPackage().unary_!()).&&(Namer.this.inCurrentScope(m)).&&(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().currentRun().compiles(m).unary_!().||(m.hasFlag(2097152L))))
        {
          Namer.this.updatePosFlags(m, tree.pos(), moduleFlags);
          Namer.this.setPrivateWithin(tree, m, tree.mods());
          Namer.this.context().unit().synthetics().-=(m)
        }
      else
        {
          m = Namer.this.context().owner().newModule(tree.pos(), tree.name());
          m.setFlag(moduleFlags);
          m = Namer.this.setPrivateWithin(tree, m, tree.mods());
          m = Namer.this.enterInScope(m);
          m.moduleClass().setFlag(Namer.this.moduleClassFlags(moduleFlags));
          Namer.this.setPrivateWithin(tree, m.moduleClass(), tree.mods())
        };
      if (m.owner().isPackageClass())
        {
          m.moduleClass().sourceFile_=(Namer.this.context().unit().source().file());
          Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().currentRun().symSource().update(m, m.moduleClass().sourceFile())
        }
      else
        ();
      m
    };
    def enterSyms(trees: List): scala.tools.nsc.typechecker.Namer = {
      var namer$1: scala.runtime.ObjectRef = new scala.runtime.ObjectRef(this);
      trees.foreach((new /*anonymous class*/ $anonfun$enterSyms$1(Namer.this, namer$1): Function1));
      namer$1.elem.$asInstanceOf[scala.tools.nsc.typechecker.Namer]()
    };
    def newTypeSkolems(tparams$1: List): List = {
      val tskolems$1: List = tparams$1.map((new /*anonymous class*/ $anonfun$1(Namer.this): Function1), immutable.this.List.canBuildFrom()).$asInstanceOf[List]();
      val ltp$1: scala.tools.nsc.symtab.LazyType = new /*anonymous class*/ $anon$3(Namer.this, tparams$1, tskolems$1);
      tskolems$1.foreach((new /*anonymous class*/ $anonfun$newTypeSkolems$1(Namer.this, ltp$1): Function1));
      tskolems$1
    };
    def skolemize(tparams: List): Unit = {
      val tskolems: List = Namer.this.newTypeSkolems(tparams.map((new /*anonymous class*/ $anonfun$2(Namer.this): Function1), immutable.this.List.canBuildFrom()).$asInstanceOf[List]());
      tparams.zip(tskolems, immutable.this.List.canBuildFrom()).$asInstanceOf[scala.collection.LinearSeqLike]().foreach((new /*anonymous class*/ $anonfun$skolemize$1(Namer.this): Function1))
    };
    def applicableTypeParams(owner: scala.tools.nsc.symtab.Symbol): List = if (owner.isTerm().||(owner.isPackageClass()))
      immutable.this.Nil
    else
      {
        /*synthetic*/ val x$5: List = Namer.this.applicableTypeParams(owner.owner());
        owner.typeParams().:::(x$5)
      };
    def ensureCompanionObject(tree: scala.tools.nsc.ast.ClassDef, creator: Function0): scala.tools.nsc.symtab.Symbol = {
      val m: scala.tools.nsc.symtab.Symbol = Namer.this.context().scope().lookup(tree.name().toTermName()).filter((new /*anonymous class*/ $anonfun$3(Namer.this): Function1));
      if (m.isModule().&&(Namer.this.inCurrentScope(m)).&&(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().currentRun().compiles(m)))
        m
      else
        Namer.this.enterSyntheticSym(creator.apply().$asInstanceOf[scala.tools.nsc.ast.Tree]())
    };
    private def enterSymFinishWith(tree$2: scala.tools.nsc.ast.Tree, tparams$2: List): Unit = {
      val sym$2: scala.tools.nsc.symtab.Symbol = tree$2.symbol();
      if (scala.Boolean.unbox(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().settings().debug().value()))
        Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().log("entered ".+(sym$2).+(" in ").+(Namer.this.context().owner()).+(", scope-id = ").+(scala.Int.box(Namer.this.context().scope().hashCode())))
      else
        ();
      var ltype$1: scala.runtime.ObjectRef = new scala.runtime.ObjectRef(Namer.this.namerOf(sym$2).typeCompleter(tree$2));
      if (tparams$2.isEmpty().unary_!())
        {
          if (sym$2.isAbstractType().unary_!())
            Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().newNamer(Namer.this.context().makeNewScope(tree$2, sym$2)).enterSyms(tparams$2)
          else
            scala.runtime.BoxedUnit.UNIT;
          ltype$1.elem = new scala.tools.nsc.typechecker.PolyTypeCompleter(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer(), tparams$2, ltype$1.elem.$asInstanceOf[scala.tools.nsc.typechecker.TypeCompleter](), tree$2, sym$2, Namer.this.context());
          if (sym$2.isTerm())
            Namer.this.skolemize(tparams$2)
          else
            ()
        }
      else
        ();
      if (sym$2.name().==(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().nme().copy()).&&(sym$2.hasFlag(2097152L)).||(sym$2.name().startsWith(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().view(scala.this.Predef.any2stringadd(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().nme().copy()).+("$default$"))).&&(Namer.this.copyIsSynthetic$1(sym$2))))
        {
          Namer.this.setInfo(sym$2, Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().mkTypeCompleter(tree$2, (new /*anonymous class*/ $anonfun$enterSymFinishWith$1(Namer.this, tree$2, tparams$2, sym$2, ltype$1): Function1)));
          ()
        }
      else
        {
          Namer.this.setInfo(sym$2, ltype$1.elem.$asInstanceOf[scala.tools.nsc.typechecker.TypeCompleter]());
          ()
        }
    };
    def enterSym(tree$1: scala.tools.nsc.ast.Tree): scala.tools.nsc.typechecker.Context = {
      if (Namer.this.sym$4(tree$1).!=(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().NoSymbol()))
        return this.context()
      else
        ();
      {
        var exceptionResult1: java.lang.Object = _;
        try {
          exceptionResult1 = {
            val owner: scala.tools.nsc.symtab.Symbol = Namer.this.context().owner();
            var temp38: scala.tools.nsc.ast.Tree = tree$1;
            if (temp38.$isInstanceOf[scala.tools.nsc.ast.PackageDef]())
              {
                var temp39: scala.tools.nsc.ast.PackageDef = temp38.$asInstanceOf[scala.tools.nsc.ast.PackageDef]();
                var temp40: scala.tools.nsc.ast.RefTree = temp39.pid();
                {
                  val temp41: List = temp39.stats();
                  {
                    val stats: List = temp41;
                    val pid: scala.tools.nsc.ast.RefTree = temp40;
                    {
                      val pid: scala.tools.nsc.ast.RefTree = temp40;
                      val stats: List = temp41;
                      // @todo check -- LabelDef 
                      body_0: 
                      /*(pid,stats)*/{
                        tree$1.symbol_=(Namer.this.enterPackageSymbol(tree$1.pos(), pid, if (Namer.this.context().owner().==(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().definitions().EmptyPackageClass()))
                          Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().definitions().RootClass()
                        else
                          Namer.this.context().owner()));
                        val namer: scala.tools.nsc.typechecker.Namer = Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().newNamer(Namer.this.context().make(tree$1, Namer.this.sym$4(tree$1).moduleClass(), Namer.this.sym$4(tree$1).info().decls()));
                        namer.enterSyms(stats)
                      };
                      /*EmptyTree*/
                    };
                    /*EmptyTree*/
                  };
                  /*EmptyTree*/
                };
                /*EmptyTree*/
              }
            else
              if (temp38.$isInstanceOf[scala.tools.nsc.ast.ClassDef]())
                {
                  var temp42: scala.tools.nsc.ast.ClassDef = temp38.$asInstanceOf[scala.tools.nsc.ast.ClassDef]();
                  var temp43: scala.tools.nsc.ast.Modifiers = temp42.mods();
                  {
                    var temp44: scala.tools.nsc.symtab.Name = temp42.name();
                    val temp45: List = temp42.tparams();
                    {
                      var temp46: scala.tools.nsc.ast.Template = temp42.impl();
                      {
                        val impl: scala.tools.nsc.ast.Template = temp46;
                        val tparams: List = temp45;
                        {
                          val name: scala.tools.nsc.symtab.Name = temp44;
                          val mods: scala.tools.nsc.ast.Modifiers = temp43;
                          {
                            val tree$5: scala.tools.nsc.ast.ClassDef = temp42;
                            val tree$5: scala.tools.nsc.ast.ClassDef = temp42;
                            val mods: scala.tools.nsc.ast.Modifiers = temp43;
                            {
                              val name: scala.tools.nsc.symtab.Name = temp44;
                              val tparams: List = temp45;
                              {
                                val impl: scala.tools.nsc.ast.Template = temp46;
                                // @todo check -- LabelDef 
                                body_1: 
                                /*(tree$5,mods,name,tparams,impl)*/{
                                  tree$5.symbol_=(Namer.this.enterClassSymbol(tree$5));
                                  Namer.this.finishWith$1(tparams, tree$1);
                                  if (mods.isCase())
                                    {
                                      val m: scala.tools.nsc.symtab.Symbol = Namer.this.ensureCompanionObject(tree$5, (new /*anonymous class*/ $anonfun$5(Namer.this, tree$5): Function0));
                                      Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().caseClassOfModuleClass().update(m.moduleClass(), tree$5)
                                    }
                                  else
                                    ();
                                  val hasDefault: Boolean = impl.body().flatMap((new /*anonymous class*/ $anonfun$6(Namer.this): Function1), immutable.this.List.canBuildFrom()).$asInstanceOf[scala.collection.LinearSeqLike]().exists((new /*anonymous class*/ $anonfun$7(Namer.this): Function1));
                                  if (hasDefault)
                                    {
                                      val m: scala.tools.nsc.symtab.Symbol = Namer.this.ensureCompanionObject(tree$5, (new /*anonymous class*/ $anonfun$8(Namer.this, tree$5): Function0));
                                      Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().classAndNamerOfModule().update(m, new Tuple2(tree$5, null));
                                      scala.runtime.BoxedUnit.UNIT;
                                      /*EmptyTree*/
                                    }
                                  else
                                    scala.runtime.BoxedUnit.UNIT
                                }
                              };
                              /*EmptyTree*/
                            };
                            /*EmptyTree*/
                          };
                          /*EmptyTree*/
                        };
                        /*EmptyTree*/
                      };
                      /*EmptyTree*/
                    };
                    /*EmptyTree*/
                  };
                  /*EmptyTree*/
                }
              else
                if (temp38.$isInstanceOf[scala.tools.nsc.ast.ModuleDef]())
                  {
                    var temp47: scala.tools.nsc.ast.ModuleDef = temp38.$asInstanceOf[scala.tools.nsc.ast.ModuleDef]();
                    var temp48: scala.tools.nsc.ast.Modifiers = temp47.mods();
                    {
                      var temp49: scala.tools.nsc.symtab.Name = temp47.name();
                      {
                        val name: scala.tools.nsc.symtab.Name = temp49;
                        val mods: scala.tools.nsc.ast.Modifiers = temp48;
                        {
                          val tree: scala.tools.nsc.ast.ModuleDef = temp47;
                          val tree: scala.tools.nsc.ast.ModuleDef = temp47;
                          val mods: scala.tools.nsc.ast.Modifiers = temp48;
                          {
                            val name: scala.tools.nsc.symtab.Name = temp49;
                            // @todo check -- LabelDef 
                            body_2: 
                            /*(tree,mods,name)*/{
                              tree.symbol_=(Namer.this.enterModuleSymbol(tree));
                              Namer.this.sym$4(tree$1).moduleClass().setInfo(Namer.this.namerOf(Namer.this.sym$4(tree$1)).moduleClassTypeCompleter(tree));
                              Namer.this.finish$1(tree$1);
                              scala.runtime.BoxedUnit.UNIT;
                              /*EmptyTree*/
                            }
                          };
                          /*EmptyTree*/
                        };
                        /*EmptyTree*/
                      };
                      /*EmptyTree*/
                    };
                    /*EmptyTree*/
                  }
                else
                  if (temp38.$isInstanceOf[scala.tools.nsc.ast.ValDef]())
                    {
                      var temp51: scala.tools.nsc.ast.ValDef = temp38.$asInstanceOf[scala.tools.nsc.ast.ValDef]();
                      var temp52: scala.tools.nsc.ast.Modifiers = temp51.mods();
                      {
                        var temp53: scala.tools.nsc.symtab.Name = temp51.name();
                        var temp54: scala.tools.nsc.ast.Tree = temp51.tpt();
                        {
                          var temp55: scala.tools.nsc.ast.Tree = temp51.rhs();
                          {
                            val rhs: scala.tools.nsc.ast.Tree = temp55;
                            val tp: scala.tools.nsc.ast.Tree = temp54;
                            {
                              val name: scala.tools.nsc.symtab.Name = temp53;
                              val mods: scala.tools.nsc.ast.Modifiers = temp52;
                              {
                                val vd: scala.tools.nsc.ast.ValDef = temp51;
                                val vd: scala.tools.nsc.ast.ValDef = temp51;
                                val mods: scala.tools.nsc.ast.Modifiers = temp52;
                                {
                                  val name: scala.tools.nsc.symtab.Name = temp53;
                                  val tp: scala.tools.nsc.ast.Tree = temp54;
                                  {
                                    val rhs: scala.tools.nsc.ast.Tree = temp55;
                                    // @todo check -- LabelDef 
                                    body_3: 
                                    /*(vd,mods,name,tp,rhs)*/{
                                      if (Namer.this.context().owner().isClass().unary_!().||(mods.flags().&(17301508).==(524292)).||(name.endsWith(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().nme().OUTER(), Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().nme().OUTER().length())).||(Namer.this.context().unit().isJava()).&&(mods.isLazy().unary_!()))
                                        {
                                          tree$1.symbol_=(Namer.this.enterInScope(owner.newValue(tree$1.pos(), name).setFlag(mods.flags())));
                                          Namer.this.finish$1(tree$1);
                                          scala.runtime.BoxedUnit.UNIT;
                                          /*EmptyTree*/
                                        }
                                      else
                                        {
                                          val mods1: scala.tools.nsc.ast.Modifiers = if (mods.hasFlag(4L).&&(mods.hasFlag(524288L)).&&(mods.isLazy().unary_!()))
                                            {
                                              Namer.this.context().error(tree$1.pos(), "private[this] not allowed for case class parameters");
                                              mods.&~(524288L)
                                            }
                                          else
                                            mods;
                                          val accflags: Long = 134217728.|(if (mods1.isVariable())
                                            mods1.flags().&(4096.unary_~()).&(137438953472L.unary_~())
                                          else
                                            mods1.flags().&(137438953472L.unary_~()).|(4194304));
                                          if (Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().nme().isSetterName(name))
                                            Namer.this.context().error(tree$1.pos(), "Names of vals or vars may not end in `_='")
                                          else
                                            ();
                                          val getter: scala.tools.nsc.symtab.TermSymbol = Namer.this.enterAliasMethod(tree$1, name, accflags, mods1);
                                          Namer.this.setInfo(getter, Namer.this.namerOf(getter).getterTypeCompleter(vd));
                                          if (mods1.isVariable())
                                            {
                                              val setter: scala.tools.nsc.symtab.TermSymbol = Namer.this.enterAliasMethod(tree$1, Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().nme().getterToSetter(name), accflags.&(4194304.unary_~()).&(16777216.unary_~()), mods1);
                                              Namer.this.setInfo(setter, Namer.this.namerOf(setter).setterTypeCompleter(vd))
                                            }
                                          else
                                            scala.runtime.BoxedUnit.UNIT;
                                          tree$1.symbol_=(if (mods1.isDeferred())
                                            getter.setPos(tree$1.pos())
                                          else
                                            {
                                              val vsym: scala.tools.nsc.symtab.TermSymbol = if (Namer.this.context().owner().isClass().unary_!())
                                                {
                                                  scala.this.Predef.assert(mods1.isLazy());
                                                  owner.newValue(tree$1.pos(), Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().view(scala.this.Predef.any2stringadd(name).+("$lzy"))).setFlag(mods1.flags().|(4096)).$asInstanceOf[scala.tools.nsc.symtab.TermSymbol]()
                                                }
                                              else
                                                {
                                                  val mFlag: Int = if (mods1.isLazy())
                                                    4096
                                                  else
                                                    0;
                                                  val lFlag: Int = if (mods.hasFlag(4L).&&(mods.hasFlag(524288L)))
                                                    0
                                                  else
                                                    524288;
                                                  val newflags: Long = mods1.flags().&(symtab.Flags.FieldFlags()).|(4).|(lFlag).|(mFlag);
                                                  owner.newValue(tree$1.pos(), Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().nme().getterToLocal(name)).setFlag(newflags).$asInstanceOf[scala.tools.nsc.symtab.TermSymbol]()
                                                };
                                              Namer.this.enterInScope(vsym);
                                              Namer.this.setInfo(vsym, Namer.this.namerOf(vsym).typeCompleter(tree$1));
                                              if (mods1.isLazy())
                                                vsym.setLazyAccessor(getter)
                                              else
                                                scala.runtime.BoxedUnit.UNIT;
                                              vsym
                                            });
                                          Namer.this.addBeanGetterSetter(vd, getter);
                                          scala.runtime.BoxedUnit.UNIT;
                                          /*EmptyTree*/
                                        }
                                    }
                                  };
                                  /*EmptyTree*/
                                };
                                /*EmptyTree*/
                              };
                              /*EmptyTree*/
                            };
                            /*EmptyTree*/
                          };
                          /*EmptyTree*/
                        };
                        /*EmptyTree*/
                      };
                      /*EmptyTree*/
                    }
                  else
                    if (temp38.$isInstanceOf[scala.tools.nsc.ast.DefDef]())
                      {
                        var temp56: scala.tools.nsc.ast.DefDef = temp38.$asInstanceOf[scala.tools.nsc.ast.DefDef]();
                        var temp57: scala.tools.nsc.ast.Modifiers = temp56.mods();
                        {
                          var temp58: scala.tools.nsc.symtab.Name = temp56.name();
                          val temp59: List = temp56.tparams();
                          if (temp58.==(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().nme().CONSTRUCTOR()))
                            {
                              val tparams: List = temp59;
                              val mods: scala.tools.nsc.ast.Modifiers = temp57;
                              {
                                val mods: scala.tools.nsc.ast.Modifiers = temp57;
                                val tparams: List = temp59;
                                // @todo check -- LabelDef 
                                body_4: 
                                /*(mods,tparams)*/{
                                  var sym: scala.tools.nsc.symtab.TermSymbol = owner.newConstructor(tree$1.pos()).setFlag(mods.flags().|(owner.getFlag(symtab.Flags.ConstrFlags()))).$asInstanceOf[scala.tools.nsc.symtab.TermSymbol]();
                                  Namer.this.setPrivateWithin(tree$1, sym, mods);
                                  tree$1.symbol_=(Namer.this.enterInScope(sym));
                                  Namer.this.finishWith$1(tparams, tree$1);
                                  scala.runtime.BoxedUnit.UNIT;
                                  /*EmptyTree*/
                                };
                                /*EmptyTree*/
                              };
                              /*EmptyTree*/
                            }
                          else
                            // @todo check -- LabelDef 
                            failCont_2: 
                            /*()*/{
                              val tparams: List = temp59;
                              val mods: scala.tools.nsc.ast.Modifiers = temp57;
                              {
                                val name: scala.tools.nsc.symtab.Name = temp58;
                                val mods: scala.tools.nsc.ast.Modifiers = temp57;
                                val name: scala.tools.nsc.symtab.Name = temp58;
                                {
                                  val tparams: List = temp59;
                                  // @todo check -- LabelDef 
                                  body_5: 
                                  /*(mods,name,tparams)*/{
                                    tree$1.symbol_=(Namer.this.enterNewMethod(tree$1, name, mods.flags(), mods, tree$1.pos()));
                                    Namer.this.finishWith$1(tparams, tree$1);
                                    scala.runtime.BoxedUnit.UNIT;
                                    /*EmptyTree*/
                                  }
                                };
                                /*EmptyTree*/
                              };
                              /*EmptyTree*/
                            };
                          /*EmptyTree*/
                        };
                        /*EmptyTree*/
                      }
                    else
                      if (temp38.$isInstanceOf[scala.tools.nsc.ast.TypeDef]())
                        {
                          var temp63: scala.tools.nsc.ast.TypeDef = temp38.$asInstanceOf[scala.tools.nsc.ast.TypeDef]();
                          var temp64: scala.tools.nsc.ast.Modifiers = temp63.mods();
                          {
                            var temp65: scala.tools.nsc.symtab.Name = temp63.name();
                            val temp66: List = temp63.tparams();
                            {
                              val tparams: List = temp66;
                              val name: scala.tools.nsc.symtab.Name = temp65;
                              {
                                val mods: scala.tools.nsc.ast.Modifiers = temp64;
                                val mods: scala.tools.nsc.ast.Modifiers = temp64;
                                val name: scala.tools.nsc.symtab.Name = temp65;
                                {
                                  val tparams: List = temp66;
                                  // @todo check -- LabelDef 
                                  body_6: 
                                  /*(mods,name,tparams)*/{
                                    var flags: Long = mods.flags();
                                    if (flags.&(8192).!=(0L))
                                      flags = flags.|(16)
                                    else
                                      ();
                                    var sym: scala.tools.nsc.symtab.TypeSymbol = new scala.tools.nsc.symtab.TypeSymbol(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global(), owner, tree$1.pos(), name).setFlag(flags).$asInstanceOf[scala.tools.nsc.symtab.TypeSymbol]();
                                    Namer.this.setPrivateWithin(tree$1, sym, mods);
                                    tree$1.symbol_=(Namer.this.enterInScope(sym));
                                    Namer.this.finishWith$1(tparams, tree$1);
                                    scala.runtime.BoxedUnit.UNIT;
                                    /*EmptyTree*/
                                  }
                                };
                                /*EmptyTree*/
                              };
                              /*EmptyTree*/
                            };
                            /*EmptyTree*/
                          };
                          /*EmptyTree*/
                        }
                      else
                        if (temp38.$isInstanceOf[scala.tools.nsc.ast.DocDef]())
                          {
                            var temp68: scala.tools.nsc.ast.DocDef = temp38.$asInstanceOf[scala.tools.nsc.ast.DocDef]();
                            {
                              var temp70: scala.tools.nsc.ast.Tree = temp68.definition();
                              {
                                val defn: scala.tools.nsc.ast.Tree = temp70;
                                val defn: scala.tools.nsc.ast.Tree = temp70;
                                // @todo check -- LabelDef 
                                body_7: 
                                /*(defn)*/{
                                  Namer.this.enterSym(defn)
                                };
                                /*EmptyTree*/
                              };
                              /*EmptyTree*/
                            };
                            /*EmptyTree*/
                          }
                        else
                          {
                            if (temp38.$isInstanceOf[scala.tools.nsc.ast.Import]())
                              {
                                var temp71: scala.tools.nsc.ast.Import = temp38.$asInstanceOf[scala.tools.nsc.ast.Import]();
                                {
                                  val imp: scala.tools.nsc.ast.Import = temp71;
                                  val imp: scala.tools.nsc.ast.Import = temp71;
                                  // @todo check -- LabelDef 
                                  body_8: 
                                  /*(imp)*/{
                                    tree$1.symbol_=(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().NoSymbol().newImport(tree$1.pos()));
                                    Namer.this.setInfo(Namer.this.sym$4(tree$1), Namer.this.namerOf(Namer.this.sym$4(tree$1)).typeCompleter(tree$1));
                                    return Namer.this.context().makeNewImport(imp)
                                  };
                                  /*EmptyTree*/
                                };
                                /*EmptyTree*/
                              }
                            else
                              ();
                            scala.runtime.BoxedUnit.UNIT
                          };
            /*EmptyTree*/
          }
        } catch {
          case (ex @ (_: scala.tools.nsc.symtab.TypeError)) => exceptionResult1 = {
            Namer.this.typer().reportTypeError(tree$1.pos(), ex);
            this.context()
          }
        };
        exceptionResult1
      };
      this.context()
    };
    def enterSyntheticSym(tree: scala.tools.nsc.ast.Tree): scala.tools.nsc.symtab.Symbol = {
      Namer.this.enterSym(tree);
      Namer.this.context().unit().synthetics().update(tree.symbol(), tree);
      tree.symbol()
    };
    def enterNewMethod(tree: scala.tools.nsc.ast.Tree, name: scala.tools.nsc.symtab.Name, flags: Long, mods: scala.tools.nsc.ast.Modifiers, pos: scala.tools.nsc.util.Position): scala.tools.nsc.symtab.TermSymbol = {
      val sym: scala.tools.nsc.symtab.TermSymbol = Namer.this.context().owner().newMethod(pos, name).setFlag(flags).$asInstanceOf[scala.tools.nsc.symtab.TermSymbol]();
      Namer.this.setPrivateWithin(tree, sym, mods);
      Namer.this.enterInScope(sym);
      sym
    };
    def enterAliasMethod(tree: scala.tools.nsc.ast.Tree, name: scala.tools.nsc.symtab.Name, flags: Long, mods: scala.tools.nsc.ast.Modifiers): scala.tools.nsc.symtab.TermSymbol = Namer.this.enterNewMethod(tree, name, flags, mods, tree.pos().focus());
    private def addBeanGetterSetter(vd: scala.tools.nsc.ast.ValDef, getter: scala.tools.nsc.symtab.Symbol): Unit = {
      /*synthetic*/ private[this] val x$11: Tuple3 = {
        var temp88: scala.tools.nsc.ast.ValDef = vd;
        if (temp88.ne(null))
          {
            var temp89: scala.tools.nsc.ast.Modifiers = temp88.mods();
            var temp90: scala.tools.nsc.symtab.Name = temp88.name();
            {
              var temp91: scala.tools.nsc.ast.Tree = temp88.tpt();
              {
                val tpt: scala.tools.nsc.ast.Tree = temp91;
                val name: scala.tools.nsc.symtab.Name = temp90;
                {
                  val mods: scala.tools.nsc.ast.Modifiers = temp89;
                  val mods: scala.tools.nsc.ast.Modifiers = temp89;
                  val name: scala.tools.nsc.symtab.Name = temp90;
                  {
                    val tpt: scala.tools.nsc.ast.Tree = temp91;
                    // @todo check -- LabelDef 
                    body_0: 
                    /*(mods,name,tpt)*/{
                      new Tuple3(mods, name, tpt)
                    }
                  };
                  /*EmptyTree*/
                };
                /*EmptyTree*/
              };
              /*EmptyTree*/
            };
            /*EmptyTree*/
          }
        else
          throw new MatchError(temp88.toString())
      };
      val mods: scala.tools.nsc.ast.Modifiers = x$11._1().$asInstanceOf[scala.tools.nsc.ast.Modifiers]();
      val name: scala.tools.nsc.symtab.Name = x$11._2().$asInstanceOf[scala.tools.nsc.symtab.Name]();
      val tpt: scala.tools.nsc.ast.Tree = x$11._3().$asInstanceOf[scala.tools.nsc.ast.Tree]();
      val hasBP: Boolean = mods.annotations().exists((new /*anonymous class*/ $anonfun$9(Namer.this): Function1));
      val hasBoolBP: Boolean = mods.annotations().exists((new /*anonymous class*/ $anonfun$10(Namer.this): Function1));
      if (hasBP.||(hasBoolBP).&&(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().forMSIL().unary_!()))
        if (scala.this.Predef.charWrapper(name.apply(0)).isLetter().unary_!())
          Namer.this.context().error(vd.pos(), "`BeanProperty' annotation can be applied only to fields that start with a letter")
        else
          if (mods.isPrivate())
            Namer.this.context().error(vd.pos(), "`BeanProperty' annotation can only be applied to non-private fields")
          else
            {
              val flags: Long = mods.flags().&(8388626);
              val beanName: java.lang.String = scala.this.Predef.augmentString(name.toString()).capitalize();
              val getterName: java.lang.String = if (hasBoolBP)
                "is".+(beanName)
              else
                "get".+(beanName);
              val getterMods: scala.tools.nsc.ast.Modifiers = new scala.tools.nsc.ast.Modifiers(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global(), flags, mods.privateWithin(), immutable.this.Nil, mods.positions());
              val beanGetterDef: scala.tools.nsc.ast.DefDef = Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().atPos(vd.pos().focus(), new scala.tools.nsc.ast.DefDef(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global(), getterMods, Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().view(getterName), immutable.this.Nil, immutable.this.List.apply(scala.this.Predef.wrapRefArray(Array[object Nil]{immutable.this.Nil}.$asInstanceOf[Array[java.lang.Object]]())), tpt.duplicate(), if (mods.isDeferred())
                Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().EmptyTree()
              else
                new scala.tools.nsc.ast.Select(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global(), new scala.tools.nsc.ast.This(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global(), getter.owner().name()), name))).$asInstanceOf[scala.tools.nsc.ast.DefDef]();
              Namer.this.enterSyntheticSym(beanGetterDef);
              if (mods.hasFlag(4096L))
                {
                  val setterName: java.lang.String = "set".+(beanName);
                  val setter: scala.tools.nsc.symtab.TermSymbol = Namer.this.enterAliasMethod(vd, Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().view(setterName), flags, mods).setPos(vd.pos().focus()).$asInstanceOf[scala.tools.nsc.symtab.TermSymbol]();
                  Namer.this.setInfo(setter, Namer.this.namerOf(setter).setterTypeCompleter(vd));
                  ();
                  /*EmptyTree*/
                }
              else
                ()
            }
      else
        ()
    };
    def typeCompleter(tree$3: scala.tools.nsc.ast.Tree): scala.tools.nsc.typechecker.TypeCompleter = Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().mkTypeCompleter(tree$3, (new /*anonymous class*/ $anonfun$typeCompleter$1(Namer.this, tree$3): Function1));
    def moduleClassTypeCompleter(tree$6: scala.tools.nsc.ast.Tree): scala.tools.nsc.typechecker.TypeCompleter = Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().mkTypeCompleter(tree$6, (new /*anonymous class*/ $anonfun$moduleClassTypeCompleter$1(Namer.this, tree$6): Function1));
    def getterTypeCompleter(vd$1: scala.tools.nsc.ast.ValDef): scala.tools.nsc.typechecker.TypeCompleter = Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().mkTypeCompleter(vd$1, (new /*anonymous class*/ $anonfun$getterTypeCompleter$1(Namer.this, vd$1): Function1));
    def setterTypeCompleter(vd$2: scala.tools.nsc.ast.ValDef): scala.tools.nsc.typechecker.TypeCompleter = Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().mkTypeCompleter(vd$2, (new /*anonymous class*/ $anonfun$setterTypeCompleter$1(Namer.this, vd$2): Function1));
    def selfTypeCompleter(tree$7: scala.tools.nsc.ast.Tree): scala.tools.nsc.typechecker.TypeCompleter = Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().mkTypeCompleter(tree$7, (new /*anonymous class*/ $anonfun$selfTypeCompleter$1(Namer.this, tree$7): Function1));
    private def widenIfNotFinal(sym: scala.tools.nsc.symtab.Symbol, tpe: scala.tools.nsc.symtab.Type, pt: scala.tools.nsc.symtab.Type): scala.tools.nsc.symtab.Type = {
      val getter$1: scala.tools.nsc.symtab.Symbol = if (sym.isValue().&&(sym.owner().isClass()).&&(sym.hasFlag(4L)))
        sym.getter(sym.owner())
      else
        sym;
      val tpe1: scala.tools.nsc.symtab.Type = tpe.deconst();
      val tpe2: scala.tools.nsc.symtab.Type = tpe1.widen();
      if (sym.isVariable().||(sym.isMethod().&&(sym.hasFlag(134217728L).unary_!())))
        if (tpe2.<:<(pt))
          tpe2
        else
          tpe1
      else
        if (Namer.this.isHidden$1(tpe, getter$1))
          tpe2
        else
          if (sym.hasFlag(32L).unary_!())
            tpe1
          else
            tpe
    };
    def enterValueParams(owner$1: scala.tools.nsc.symtab.Symbol, vparamss: List): List = vparamss.map((new /*anonymous class*/ $anonfun$enterValueParams$1(Namer.this, owner$1): Function1), immutable.this.List.canBuildFrom()).$asInstanceOf[List]();
    private def templateSig(templ: scala.tools.nsc.ast.Template): scala.tools.nsc.symtab.Type = {
      val clazz$1: scala.tools.nsc.symtab.Symbol = Namer.this.context().owner();
      var parents: List = Namer.this.typer().parentTypes(templ).map((new /*anonymous class*/ $anonfun$11(Namer.this): Function1), immutable.this.List.canBuildFrom()).$asInstanceOf[List]();
      Namer.this.enterSelf$1(templ.self(), clazz$1);
      val decls: scala.tools.nsc.symtab.Scope = new scala.tools.nsc.symtab.Scope(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global());
      val templateNamer: scala.tools.nsc.typechecker.Namer = Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().newNamer(Namer.this.context().make(templ, clazz$1, decls)).enterSyms(templ.body());
      {
        val temp109: Option = Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().caseClassOfModuleClass().get(clazz$1);
        if (temp109.$isInstanceOf[Some]())
          {
            var temp110: Some = temp109.$asInstanceOf[Some]();
            var temp111: scala.tools.nsc.ast.ClassDef = temp110.x().$asInstanceOf[scala.tools.nsc.ast.ClassDef]();
            {
              val cdef: scala.tools.nsc.ast.ClassDef = temp111;
              val cdef: scala.tools.nsc.ast.ClassDef = temp111;
              // @todo check -- LabelDef 
              body_0: 
              /*(cdef)*/{
                Namer.this.addApplyUnapply(cdef, templateNamer);
                Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().caseClassOfModuleClass().-=(clazz$1)
              };
              /*EmptyTree*/
            };
            /*EmptyTree*/
          }
        else
          {
            if (scala.this.None.==(temp109))
              ()
            else
              throw new MatchError(temp109.toString());
            scala.runtime.BoxedUnit.UNIT
          }
      };
      {
        val temp113: Option = Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().caseClassOfModuleClass().get(clazz$1.linkedModuleOfClass().moduleClass());
        if (temp113.$isInstanceOf[Some]())
          {
            var temp114: Some = temp113.$asInstanceOf[Some]();
            var temp115: scala.tools.nsc.ast.ClassDef = temp114.x().$asInstanceOf[scala.tools.nsc.ast.ClassDef]();
            {
              val cdef: scala.tools.nsc.ast.ClassDef = temp115;
              val cdef: scala.tools.nsc.ast.ClassDef = temp115;
              // @todo check -- LabelDef 
              body_0: 
              /*(cdef)*/{
                if (Namer.this.hasCopy$1(decls).unary_!().&&(parents.exists((new /*anonymous class*/ $anonfun$templateSig$1(Namer.this): Function1)).unary_!()).&&(parents.flatMap((new /*anonymous class*/ $anonfun$templateSig$2(Namer.this): Function1), immutable.this.List.canBuildFrom()).$asInstanceOf[scala.collection.SeqLike]().removeDuplicates().$asInstanceOf[scala.collection.LinearSeqLike]().exists((new /*anonymous class*/ $anonfun$templateSig$3(Namer.this): Function1)).unary_!()))
                  Namer.this.addCopyMethod(cdef, templateNamer)
                else
                  ()
              };
              /*EmptyTree*/
            };
            /*EmptyTree*/
          }
        else
          if (scala.this.None.==(temp113))
            ()
          else
            throw new MatchError(temp113.toString())
      };
      val module: scala.tools.nsc.symtab.Symbol = clazz$1.sourceModule();
      if (Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().classAndNamerOfModule().contains(module))
        {
          val cdef: scala.tools.nsc.ast.ClassDef = {
            var temp117: Tuple2 = Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().classAndNamerOfModule().apply(module).$asInstanceOf[Tuple2]();
            if (temp117.ne(null))
              {
                var temp118: scala.tools.nsc.ast.ClassDef = temp117._1().$asInstanceOf[scala.tools.nsc.ast.ClassDef]();
                {
                  val cdef: scala.tools.nsc.ast.ClassDef = temp118;
                  val cdef: scala.tools.nsc.ast.ClassDef = temp118;
                  // @todo check -- LabelDef 
                  body_0: 
                  /*(cdef)*/{
                    cdef
                  };
                  /*EmptyTree*/
                };
                /*EmptyTree*/
              }
            else
              throw new MatchError(temp117.toString())
          };
          Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().classAndNamerOfModule().update(module, new Tuple2(cdef, templateNamer))
        }
      else
        ();
      new scala.tools.nsc.symtab.ClassInfoType(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global(), parents, decls, clazz$1)
    };
    private def classSig(tparams: List, impl: scala.tools.nsc.ast.Template): scala.tools.nsc.symtab.Type = Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().polyType(Namer.this.typer().reenterTypeParams(tparams), Namer.this.templateSig(impl));
    private def methodSig(mods: scala.tools.nsc.ast.Modifiers, tparams$3: List, vparamss: List, tpt: scala.tools.nsc.ast.Tree, rhs: scala.tools.nsc.ast.Tree): scala.tools.nsc.symtab.Type = {
      val meth$1: scala.tools.nsc.symtab.Symbol = Namer.this.context().owner();
      val tparamSyms$1: List = Namer.this.typer().reenterTypeParams(tparams$3);
      var vparamSymss$1: scala.runtime.ObjectRef = new scala.runtime.ObjectRef(Namer.this.enterValueParams(meth$1, vparamss));
      if (tpt.isEmpty().&&(meth$1.name().==(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().nme().CONSTRUCTOR())))
        {
          tpt.defineType(Namer.this.context().enclClass().owner().tpe());
          tpt.setPos(meth$1.pos().focus())
        }
      else
        scala.runtime.BoxedUnit.UNIT;
      val checkDependencies$1: scala.tools.nsc.symtab.TypeTraverser = new /*anonymous class*/ $anon$2(Namer.this, meth$1, vparamSymss$1);
      var resultPt$1: scala.runtime.ObjectRef = new scala.runtime.ObjectRef(if (tpt.isEmpty())
        Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().WildcardType()
      else
        Namer.this.typer().typedType(tpt).tpe());
      val site$1: scala.tools.nsc.symtab.Type = meth$1.owner().thisType();
      if (meth$1.owner().isClass().&&(tpt.isEmpty().||(vparamss.exists((new /*anonymous class*/ $anonfun$/*method*/Sig$1(Namer.this): Function1)))))
        {
          vparamss.foreach((new /*anonymous class*/ $anonfun$/*method*/Sig$2(Namer.this): Function1));
          val overridden: scala.tools.nsc.symtab.Symbol = Namer.this.overriddenSymbol$1(tparams$3, meth$1, tparamSyms$1, vparamSymss$1, checkDependencies$1, resultPt$1, site$1);
          if (overridden.!=(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().NoSymbol()).&&(overridden.hasFlag(8589934592L).unary_!()))
            {
              resultPt$1.elem = {
                var temp134: scala.tools.nsc.symtab.Type = site$1.memberType(overridden);
                if (temp134.$isInstanceOf[scala.tools.nsc.symtab.PolyType]())
                  {
                    var temp135: scala.tools.nsc.symtab.PolyType = temp134.$asInstanceOf[scala.tools.nsc.symtab.PolyType]();
                    val temp136: List = temp135.typeParams();
                    {
                      var temp137: scala.tools.nsc.symtab.Type = temp135.resultType();
                      {
                        val rt: scala.tools.nsc.symtab.Type = temp137;
                        val tparams: List = temp136;
                        {
                          val tparams: List = temp136;
                          val rt: scala.tools.nsc.symtab.Type = temp137;
                          // @todo check -- LabelDef 
                          body_0: 
                          /*(tparams,rt)*/{
                            rt.substSym(tparams, tparamSyms$1)
                          };
                          /*EmptyTree*/
                        };
                        /*EmptyTree*/
                      };
                      /*EmptyTree*/
                    };
                    /*EmptyTree*/
                  }
                else
                  {
                    val mt: scala.tools.nsc.symtab.Type = temp134;
                    val mt: scala.tools.nsc.symtab.Type = temp134;
                    // @todo check -- LabelDef 
                    body_1: 
                    /*(mt)*/{
                      mt
                    };
                    /*EmptyTree*/
                  }
              };
              vparamss.foreach((new /*anonymous class*/ $anonfun$/*method*/Sig$3(Namer.this, resultPt$1): Function1));
              {
                var temp138: scala.tools.nsc.symtab.Type = resultPt$1.elem.$asInstanceOf[scala.tools.nsc.symtab.Type]();
                if (temp138.$isInstanceOf[scala.tools.nsc.symtab.PolyType]())
                  {
                    var temp139: scala.tools.nsc.symtab.PolyType = temp138.$asInstanceOf[scala.tools.nsc.symtab.PolyType]();
                    {
                      var temp141: scala.tools.nsc.symtab.Type = temp139.resultType();
                      if (temp139.typeParams().$isInstanceOf[object Nil]())
                        {
                          val rtpe: scala.tools.nsc.symtab.Type = temp141;
                          val rtpe: scala.tools.nsc.symtab.Type = temp141;
                          // @todo check -- LabelDef 
                          body_0: 
                          /*(rtpe)*/{
                            resultPt$1.elem = rtpe
                          };
                          /*EmptyTree*/
                        }
                      else
                        ()
                    };
                    /*EmptyTree*/
                  }
                else
                  if (temp138.$isInstanceOf[scala.tools.nsc.symtab.MethodType]())
                    {
                      var temp143: scala.tools.nsc.symtab.MethodType = temp138.$asInstanceOf[scala.tools.nsc.symtab.MethodType]();
                      {
                        var temp145: scala.tools.nsc.symtab.Type = temp143.resultType();
                        if (temp143.params().$isInstanceOf[object Nil]())
                          {
                            val rtpe: scala.tools.nsc.symtab.Type = temp145;
                            val rtpe: scala.tools.nsc.symtab.Type = temp145;
                            // @todo check -- LabelDef 
                            body_1: 
                            /*(rtpe)*/{
                              resultPt$1.elem = rtpe
                            };
                            /*EmptyTree*/
                          }
                        else
                          ()
                      };
                      /*EmptyTree*/
                    }
                  else
                    ()
              };
              if (tpt.isEmpty())
                meth$1.setInfo(Namer.this.thisMethodType$1(resultPt$1.elem.$asInstanceOf[scala.tools.nsc.symtab.Type](), meth$1, tparamSyms$1, vparamSymss$1, checkDependencies$1))
              else
                scala.runtime.BoxedUnit.UNIT
            }
          else
            scala.runtime.BoxedUnit.UNIT
        }
      else
        scala.runtime.BoxedUnit.UNIT;
      if (meth$1.owner().isClass().&&(vparamss.isEmpty()).&&(Namer.this.overriddenSymbol$1(tparams$3, meth$1, tparamSyms$1, vparamSymss$1, checkDependencies$1, resultPt$1, site$1).alternatives().exists((new /*anonymous class*/ $anonfun$/*method*/Sig$4(Namer.this): Function1))))
        vparamSymss$1.elem = immutable.this.List.apply(scala.this.Predef.wrapRefArray(Array[List]{immutable.this.Nil}.$asInstanceOf[Array[java.lang.Object]]()))
      else
        ();
      vparamss.foreach((new /*anonymous class*/ $anonfun$/*method*/Sig$5(Namer.this): Function1));
      Namer.this.addDefaultGetters(meth$1, vparamss, tparams$3, (new /*anonymous class*/ $anonfun$/*method*/Sig$6(Namer.this, tparams$3, meth$1, tparamSyms$1, vparamSymss$1, checkDependencies$1, resultPt$1, site$1): Function0));
      Namer.this.thisMethodType$1({
        val rt: scala.tools.nsc.symtab.Type = if (tpt.isEmpty())
          {
            val pt: scala.tools.nsc.symtab.Type = resultPt$1.elem.$asInstanceOf[scala.tools.nsc.symtab.Type]().substSym(tparamSyms$1, tparams$3.map((new /*anonymous class*/ $anonfun$13(Namer.this): Function1), immutable.this.List.canBuildFrom()).$asInstanceOf[List]());
            tpt.defineType(Namer.this.widenIfNotFinal(meth$1, Namer.this.typer().computeType(rhs, pt), pt));
            tpt.setPos(meth$1.pos().focus());
            tpt.tpe()
          }
        else
          Namer.this.typer().typedType(tpt).tpe();
        if (meth$1.hasFlag(33554432L))
          rt.withAnnotation(new scala.tools.nsc.symtab.AnnotationInfo(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global(), Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().definitions().uncheckedVarianceClass().tpe(), immutable.this.Nil, immutable.this.Nil))
        else
          rt
      }, meth$1, tparamSyms$1, vparamSymss$1, checkDependencies$1)
    };
    private def addDefaultGetters(meth$2: scala.tools.nsc.symtab.Symbol, vparamss: List, tparams$4: List, overriddenSymbol: Function0): Unit = {
      val isConstr$1: Boolean = meth$2.isConstructor();
      val overridden$1: scala.tools.nsc.symtab.Symbol = if (isConstr$1.||(meth$2.owner().isClass().unary_!()))
        Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().NoSymbol()
      else
        overriddenSymbol.apply().$asInstanceOf[scala.tools.nsc.symtab.Symbol]();
      val overrides$1: Boolean = overridden$1.!=(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().NoSymbol()).&&(overridden$1.hasFlag(8589934592L).unary_!());
      var baseParamss$1: scala.runtime.ObjectRef = new scala.runtime.ObjectRef(overridden$1.tpe().paramss());
      if (vparamss.isEmpty().&&(baseParamss$1.elem.$asInstanceOf[List]().==(immutable.this.List.apply(scala.this.Predef.wrapRefArray(Array[object Nil]{immutable.this.Nil}.$asInstanceOf[Array[java.lang.Object]]())))))
        baseParamss$1.elem = immutable.this.Nil
      else
        ();
      if (vparamss.==(immutable.this.List.apply(scala.this.Predef.wrapRefArray(Array[object Nil]{immutable.this.Nil}.$asInstanceOf[Array[java.lang.Object]]()))).&&(baseParamss$1.elem.$asInstanceOf[List]().isEmpty()))
        baseParamss$1.elem = immutable.this.List.apply(scala.this.Predef.wrapRefArray(Array[object Nil]{immutable.this.Nil}.$asInstanceOf[Array[java.lang.Object]]()))
      else
        ();
      scala.this.Predef.assert(overrides$1.unary_!().||(vparamss.length().==(baseParamss$1.elem.$asInstanceOf[List]().length())), (new /*anonymous class*/ $anonfun$addDefaultGetters$1(Namer.this, meth$2, overridden$1): Function0));
      var ownerNamer$1: scala.runtime.ObjectRef = new scala.runtime.ObjectRef(scala.None);
      var moduleNamer$1: scala.runtime.ObjectRef = new scala.runtime.ObjectRef(scala.None);
      var posCounter$1: scala.runtime.IntRef = new scala.runtime.IntRef(1);
      /*synthetic*/ val x$23: List = immutable.this.Nil;
      {
        vparamss./:(x$23, (new /*anonymous class*/ $anonfun$addDefaultGetters$2(Namer.this, meth$2, tparams$4, isConstr$1, overridden$1, overrides$1, baseParamss$1, ownerNamer$1, moduleNamer$1, posCounter$1): Function2));
        ()
      };
      /*EmptyTree*/
    };
    private def typeDefSig(tpsym$1: scala.tools.nsc.symtab.Symbol, tparams: List, rhs: scala.tools.nsc.ast.Tree): scala.tools.nsc.symtab.Type = {
      val tparamSyms$2: List = Namer.this.typer().reenterTypeParams(tparams);
      val tp: scala.tools.nsc.symtab.Type = {
        var temp169: scala.tools.nsc.symtab.Type = Namer.this.typer().typedType(rhs).tpe();
        if (temp169.$isInstanceOf[scala.tools.nsc.symtab.TypeBounds]())
          {
            var temp170: scala.tools.nsc.symtab.TypeBounds = temp169.$asInstanceOf[scala.tools.nsc.symtab.TypeBounds]();
            var temp171: scala.tools.nsc.symtab.Type = temp170.lo();
            {
              var temp172: scala.tools.nsc.symtab.Type = temp170.hi();
              {
                val rt: scala.tools.nsc.symtab.Type = temp172;
                val lt: scala.tools.nsc.symtab.Type = temp171;
                if (Namer.this.gd5$1(lt, rt))
                  {
                    val lt: scala.tools.nsc.symtab.Type = temp171;
                    val rt: scala.tools.nsc.symtab.Type = temp172;
                    // @todo check -- LabelDef 
                    body_0: 
                    /*(lt,rt)*/{
                      new scala.tools.nsc.symtab.TypeBounds(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global(), Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().definitions().NothingClass().tpe(), Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().definitions().AnyClass().tpe())
                    };
                    /*EmptyTree*/
                  }
                else
                  {
                    val rt: scala.tools.nsc.symtab.Type = temp172;
                    val lt: scala.tools.nsc.symtab.Type = temp171;
                    {
                      val tp: scala.tools.nsc.symtab.TypeBounds = temp170;
                      if (Namer.this.gd6$1(tp, lt, rt, tpsym$1))
                        {
                          val tp: scala.tools.nsc.symtab.TypeBounds = temp170;
                          val lt: scala.tools.nsc.symtab.Type = temp171;
                          {
                            val rt: scala.tools.nsc.symtab.Type = temp172;
                            // @todo check -- LabelDef 
                            body_1: 
                            /*(tp,lt,rt)*/{
                              new scala.tools.nsc.symtab.TypeBounds(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global(), lt, Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().objToAny(rt))
                            }
                          };
                          /*EmptyTree*/
                        }
                      else
                        {
                          val tp: scala.tools.nsc.symtab.Type = temp170;
                          val tp: scala.tools.nsc.symtab.Type = temp170;
                          // @todo check -- LabelDef 
                          body_2: 
                          /*(tp)*/{
                            tp
                          };
                          /*EmptyTree*/
                        }
                    };
                    /*EmptyTree*/
                  };
                /*EmptyTree*/
              };
              /*EmptyTree*/
            };
            /*EmptyTree*/
          }
        else
           () // @todo -- goto body_2 /* vargs (temp169)*/
          
      };
      if (tpsym$1.owner().isRefinementClass().&&(tpsym$1.allOverriddenSymbols().forall((new /*anonymous class*/ $anonfun$typeDefSig$1(Namer.this, tpsym$1, tparamSyms$2): Function1)).unary_!()))
        Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().ErrorType()
      else
        Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().polyType(tparamSyms$2, tp)
    };
    def addApplyUnapply(cdef: scala.tools.nsc.ast.ClassDef, namer: scala.tools.nsc.typechecker.Namer): Unit = {
      if (cdef.symbol().hasFlag(8L).unary_!())
        {
          val applyMethod: scala.tools.nsc.ast.DefDef = Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().caseModuleApplyMeth(cdef);
          if (applyMethod.vparamss().size().>(2))
            Namer.this.context().error(cdef.symbol().pos(), "case classes limited by implementation: maximum of 2 constructor parameter lists.")
          else
            ();
          namer.enterSyntheticSym(applyMethod)
        }
      else
        scala.runtime.BoxedUnit.UNIT;
      namer.enterSyntheticSym(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().caseModuleUnapplyMeth(cdef));
      ();
      /*EmptyTree*/
    };
    def addCopyMethod(cdef: scala.tools.nsc.ast.ClassDef, namer$2: scala.tools.nsc.typechecker.Namer): Unit = Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().caseClassCopyMeth(cdef).foreach((new /*anonymous class*/ $anonfun$addCopyMethod$1(Namer.this, namer$2): Function1));
    def typeSig(tree$4: scala.tools.nsc.ast.Tree): scala.tools.nsc.symtab.Type = {
      val sym: scala.tools.nsc.symtab.Symbol = tree$4.symbol();
      val annotated: scala.tools.nsc.symtab.Symbol = if (sym.isModule())
        sym.moduleClass()
      else
        sym;
      if (annotated.isInitialized().unary_!())
        {
          var temp173: scala.tools.nsc.ast.Tree = tree$4;
          if (temp173.$isInstanceOf[scala.tools.nsc.ast.MemberDef]())
            {
              var temp174: scala.tools.nsc.ast.MemberDef = temp173.$asInstanceOf[scala.tools.nsc.ast.MemberDef]();
              {
                val defn: scala.tools.nsc.ast.MemberDef = temp174;
                val defn: scala.tools.nsc.ast.MemberDef = temp174;
                // @todo check -- LabelDef 
                body_0: 
                /*(defn)*/{
                  val ainfos: List = defn.mods().annotations().filter((new /*anonymous class*/ $anonfun$21(Namer.this): Function1)).$asInstanceOf[scala.collection.TraversableLike]().map((new /*anonymous class*/ $anonfun$22(Namer.this): Function1), immutable.this.List.canBuildFrom()).$asInstanceOf[List]();
                  if (ainfos.isEmpty().unary_!())
                    annotated.setAnnotations(ainfos)
                  else
                    scala.runtime.BoxedUnit.UNIT;
                  if (annotated.isTypeSkolem())
                    annotated.deSkolemize().setAnnotations(ainfos)
                  else
                    scala.runtime.BoxedUnit.UNIT
                };
                /*EmptyTree*/
              };
              /*EmptyTree*/
            }
          else
            {
              ();
              scala.runtime.BoxedUnit.UNIT
            }
        }
      else
        scala.runtime.BoxedUnit.UNIT;
      val result: scala.tools.nsc.symtab.Type = {
        var exceptionResult2: scala.tools.nsc.symtab.Type = _;
        try {
          exceptionResult2 = {
            var temp184: scala.tools.nsc.ast.Tree = tree$4;
            if (temp184.$isInstanceOf[scala.tools.nsc.ast.ClassDef]())
              {
                var temp185: scala.tools.nsc.ast.ClassDef = temp184.$asInstanceOf[scala.tools.nsc.ast.ClassDef]();
                {
                  val temp188: List = temp185.tparams();
                  var temp189: scala.tools.nsc.ast.Template = temp185.impl();
                  {
                    val impl: scala.tools.nsc.ast.Template = temp189;
                    val tparams: List = temp188;
                    {
                      val tparams: List = temp188;
                      val impl: scala.tools.nsc.ast.Template = temp189;
                      // @todo check -- LabelDef 
                      body_0: 
                      /*(tparams,impl)*/{
                        Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().newNamer(Namer.this.context().makeNewScope(tree$4, sym)).classSig(tparams, impl)
                      };
                      /*EmptyTree*/
                    };
                    /*EmptyTree*/
                  };
                  /*EmptyTree*/
                };
                /*EmptyTree*/
              }
            else
              if (temp184.$isInstanceOf[scala.tools.nsc.ast.ModuleDef]())
                {
                  var temp190: scala.tools.nsc.ast.ModuleDef = temp184.$asInstanceOf[scala.tools.nsc.ast.ModuleDef]();
                  {
                    var temp193: scala.tools.nsc.ast.Template = temp190.impl();
                    {
                      val impl: scala.tools.nsc.ast.Template = temp193;
                      val impl: scala.tools.nsc.ast.Template = temp193;
                      // @todo check -- LabelDef 
                      body_1: 
                      /*(impl)*/{
                        val clazz: scala.tools.nsc.symtab.Symbol = sym.moduleClass();
                        clazz.setInfo(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().newNamer(Namer.this.context().makeNewScope(tree$4, clazz)).templateSig(impl));
                        clazz.tpe()
                      };
                      /*EmptyTree*/
                    };
                    /*EmptyTree*/
                  };
                  /*EmptyTree*/
                }
              else
                if (temp184.$isInstanceOf[scala.tools.nsc.ast.DefDef]())
                  {
                    var temp194: scala.tools.nsc.ast.DefDef = temp184.$asInstanceOf[scala.tools.nsc.ast.DefDef]();
                    var temp195: scala.tools.nsc.ast.Modifiers = temp194.mods();
                    {
                      val temp197: List = temp194.tparams();
                      val temp198: List = temp194.vparamss();
                      {
                        var temp199: scala.tools.nsc.ast.Tree = temp194.tpt();
                        var temp200: scala.tools.nsc.ast.Tree = temp194.rhs();
                        {
                          val rhs: scala.tools.nsc.ast.Tree = temp200;
                          val tpt: scala.tools.nsc.ast.Tree = temp199;
                          {
                            val vparamss: List = temp198;
                            val tparams: List = temp197;
                            {
                              val mods: scala.tools.nsc.ast.Modifiers = temp195;
                              val mods: scala.tools.nsc.ast.Modifiers = temp195;
                              val tparams: List = temp197;
                              {
                                val vparamss: List = temp198;
                                val tpt: scala.tools.nsc.ast.Tree = temp199;
                                {
                                  val rhs: scala.tools.nsc.ast.Tree = temp200;
                                  // @todo check -- LabelDef 
                                  body_2: 
                                  /*(mods,tparams,vparamss,tpt,rhs)*/{
                                    Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().newNamer(Namer.this.context().makeNewScope(tree$4, sym)).methodSig(mods, tparams, vparamss, tpt, rhs)
                                  }
                                };
                                /*EmptyTree*/
                              };
                              /*EmptyTree*/
                            };
                            /*EmptyTree*/
                          };
                          /*EmptyTree*/
                        };
                        /*EmptyTree*/
                      };
                      /*EmptyTree*/
                    };
                    /*EmptyTree*/
                  }
                else
                  if (temp184.$isInstanceOf[scala.tools.nsc.ast.ValDef]())
                    {
                      var temp201: scala.tools.nsc.ast.ValDef = temp184.$asInstanceOf[scala.tools.nsc.ast.ValDef]();
                      var temp202: scala.tools.nsc.ast.Modifiers = temp201.mods();
                      {
                        var temp203: scala.tools.nsc.symtab.Name = temp201.name();
                        var temp204: scala.tools.nsc.ast.Tree = temp201.tpt();
                        {
                          var temp205: scala.tools.nsc.ast.Tree = temp201.rhs();
                          {
                            val rhs: scala.tools.nsc.ast.Tree = temp205;
                            val tpt: scala.tools.nsc.ast.Tree = temp204;
                            {
                              val name: scala.tools.nsc.symtab.Name = temp203;
                              val mods: scala.tools.nsc.ast.Modifiers = temp202;
                              {
                                val vdef: scala.tools.nsc.ast.ValDef = temp201;
                                val vdef: scala.tools.nsc.ast.ValDef = temp201;
                                val mods: scala.tools.nsc.ast.Modifiers = temp202;
                                {
                                  val name: scala.tools.nsc.symtab.Name = temp203;
                                  val tpt: scala.tools.nsc.ast.Tree = temp204;
                                  {
                                    val rhs: scala.tools.nsc.ast.Tree = temp205;
                                    do
                                      val typer1: scala.tools.nsc.typechecker.Typer = Namer.this.typer().constrTyperIf(sym.hasFlag(137438961664L).&&(sym.owner().isConstructor()))
                                    while (tpt.isEmpty())
                                    
                                  };
                                  /*EmptyTree*/
                                };
                                /*EmptyTree*/
                              };
                              /*EmptyTree*/
                            };
                            /*EmptyTree*/
                          };
                          /*EmptyTree*/
                        };
                        /*EmptyTree*/
                      };
                      /*EmptyTree*/
                    }
                  else
                    if (temp184.$isInstanceOf[scala.tools.nsc.ast.TypeDef]())
                      {
                        var temp206: scala.tools.nsc.ast.TypeDef = temp184.$asInstanceOf[scala.tools.nsc.ast.TypeDef]();
                        {
                          val temp209: List = temp206.tparams();
                          var temp210: scala.tools.nsc.ast.Tree = temp206.rhs();
                          {
                            val rhs: scala.tools.nsc.ast.Tree = temp210;
                            val tparams: List = temp209;
                            {
                              val tparams: List = temp209;
                              val rhs: scala.tools.nsc.ast.Tree = temp210;
                              // @todo check -- LabelDef 
                              body_4: 
                              /*(tparams,rhs)*/{
                                Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().newNamer(Namer.this.context().makeNewScope(tree$4, sym)).typeDefSig(sym, tparams, rhs)
                              };
                              /*EmptyTree*/
                            };
                            /*EmptyTree*/
                          };
                          /*EmptyTree*/
                        };
                        /*EmptyTree*/
                      }
                    else
                      if (temp184.$isInstanceOf[scala.tools.nsc.ast.Import]())
                        {
                          var temp211: scala.tools.nsc.ast.Import = temp184.$asInstanceOf[scala.tools.nsc.ast.Import]();
                          var temp212: scala.tools.nsc.ast.Tree = temp211.expr();
                          {
                            val temp213: List = temp211.selectors();
                            {
                              val selectors: List = temp213;
                              val expr$1: scala.tools.nsc.ast.Tree = temp212;
                              {
                                val expr$1: scala.tools.nsc.ast.Tree = temp212;
                                val selectors: List = temp213;
                                // @todo check -- LabelDef 
                                body_5: 
                                /*(expr$1,selectors)*/{
                                  val expr1$1: scala.tools.nsc.ast.Tree = Namer.this.typer().typedQualifier(expr$1);
                                  val base$1: scala.tools.nsc.symtab.Type = expr1$1.tpe();
                                  Namer.this.typer().checkStable(expr1$1);
                                  if (expr1$1.symbol().ne(null).&&(expr1$1.symbol().isRootPackage()))
                                    Namer.this.context().error(tree$4.pos(), "_root_ cannot be imported")
                                  else
                                    ();
                                  Namer.this.checkSelectors$1(selectors, tree$4, expr$1, expr1$1, base$1);
                                  new scala.tools.nsc.typechecker.ImportType(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer(), expr1$1)
                                };
                                /*EmptyTree*/
                              };
                              /*EmptyTree*/
                            };
                            /*EmptyTree*/
                          };
                          /*EmptyTree*/
                        }
                      else
                        throw new MatchError(temp184.toString())
          }
        } catch {
          case (ex @ (_: scala.tools.nsc.symtab.TypeError)) => exceptionResult2 = {
            Namer.this.typer().reportTypeError(tree$4.pos(), ex);
            Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().ErrorType()
          }
        };
        exceptionResult2
      };
      {
        var temp214: scala.tools.nsc.symtab.Type = result;
        if (temp214.$isInstanceOf[scala.tools.nsc.symtab.PolyType]())
          {
            var temp215: scala.tools.nsc.symtab.PolyType = temp214.$asInstanceOf[scala.tools.nsc.symtab.PolyType]();
            val temp216: List = temp215.typeParams();
            {
              var temp217: scala.tools.nsc.symtab.Type = temp215.resultType();
              {
                val restpe: scala.tools.nsc.symtab.Type = temp217;
                val tparams: List = temp216;
                if (Namer.this.gd7$1(tparams, restpe))
                  {
                    val tparams: List = temp216;
                    val restpe: scala.tools.nsc.symtab.Type = temp217;
                    // @todo check -- LabelDef 
                    body_0: 
                    /*(tparams,restpe)*/{
                      new scala.tools.nsc.typechecker.DeSkolemizeMap(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer(), tparams).mapOver(result)
                    };
                    /*EmptyTree*/
                  }
                else
                  // @todo check -- LabelDef 
                  body_1: 
                  /*()*/{
                    result
                  };
                /*EmptyTree*/
              };
              /*EmptyTree*/
            };
            /*EmptyTree*/
          }
        else
           () // @todo -- goto body_1 /* vargs ()*/
          
      };
      /*EmptyTree*/
    };
    def validate(sym$3: scala.tools.nsc.symtab.Symbol): Unit = {
      if (sym$3.hasFlag(512L).&&(sym$3.isTerm().unary_!()))
        Namer.this.context().error(sym$3.pos(), "`implicit' modifier can be used only for values, variables and methods")
      else
        ();
      if (sym$3.hasFlag(512L).&&(sym$3.owner().isPackageClass()))
        Namer.this.context().error(sym$3.pos(), "`implicit' modifier cannot be used for top-level objects")
      else
        ();
      if (sym$3.hasFlag(1024L).&&(sym$3.isClass().unary_!()))
        Namer.this.context().error(sym$3.pos(), "`sealed' modifier can be used only for classes")
      else
        ();
      if (sym$3.hasFlag(8L).&&(sym$3.isClass().unary_!()))
        Namer.this.context().error(sym$3.pos(), "`abstract' modifier can be used only for classes; \012it should be omitted for abstract members")
      else
        ();
      if (sym$3.hasFlag(262146L).&&(sym$3.hasFlag(33554432L).unary_!()).&&(sym$3.isClass()))
        Namer.this.context().error(sym$3.pos(), "`override' modifier not allowed for classes")
      else
        ();
      if (sym$3.hasFlag(262146L).&&(sym$3.isConstructor()))
        Namer.this.context().error(sym$3.pos(), "`override' modifier not allowed for constructors")
      else
        ();
      if (sym$3.hasFlag(262144L).&&(sym$3.owner().isTrait().unary_!()))
        Namer.this.context().error(sym$3.pos(), "`abstract override' modifier only allowed for members of traits")
      else
        ();
      if (sym$3.hasFlag(2147483648L).&&(sym$3.hasFlag(137438953472L)))
        Namer.this.context().error(sym$3.pos(), "`lazy' definitions may not be initialized early")
      else
        ();
      if (sym$3.info().typeSymbol().==(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().definitions().FunctionClass().apply(0)).&&(sym$3.isValueParameter()).&&(sym$3.owner().isClass()).&&(sym$3.owner().hasFlag(2048L)))
        Namer.this.context().error(sym$3.pos(), "pass-by-name arguments not allowed for case class parameters")
      else
        ();
      if (sym$3.hasFlag(16L))
        if (sym$3.hasAnnotation(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().definitions().NativeAttr()))
          sym$3.resetFlag(16L)
        else
          if (sym$3.isValueParameter().unary_!().&&(sym$3.isTypeParameterOrSkolem().unary_!()).&&(Namer.this.context().tree().$isInstanceOf[scala.tools.nsc.ast.ExistentialTypeTree]().unary_!()).&&(sym$3.owner().isClass().unary_!().||(sym$3.owner().isModuleClass()).||(sym$3.owner().isAnonymousClass())))
            {
              Namer.this.context().error(sym$3.pos(), "only classes can have declared but undefined members".+(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().varNotice(sym$3)));
              sym$3.resetFlag(16L)
            }
          else
            scala.runtime.BoxedUnit.UNIT
      else
        scala.runtime.BoxedUnit.UNIT;
      Namer.this.checkNoConflict$1(16, 4, sym$3);
      Namer.this.checkNoConflict$1(32, 1024, sym$3);
      Namer.this.checkNoConflict$1(4, 1, sym$3);
      Namer.this.checkNoConflict$1(4, 2, sym$3);
      Namer.this.checkNoConflict$1(8, 32, sym$3);
      Namer.this.checkNoConflict$1(16, 32, sym$3)
    };
    protected /*synthetic*/ /*paramaccessor*/ val $outer: scala.tools.nsc.typechecker.Analyzer = _;
    /*synthetic*/ /*stable*/ def scala$tools$nsc$typechecker$Namers$Namer$$$outer(): scala.tools.nsc.typechecker.Analyzer = Namer.this.$outer;
    final private[this] def innerNamer$1(): scala.tools.nsc.typechecker.Namer = {
      if (Namer.this.innerNamerCache().eq(null))
        Namer.this.innerNamerCache_=(if (Namer.this.isTemplateContext(Namer.this.context()).unary_!())
          this
        else
          Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().newNamer(Namer.this.context().make(Namer.this.context().tree(), Namer.this.context().owner(), new scala.tools.nsc.symtab.Scope(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global()))))
      else
        ();
      Namer.this.innerNamerCache()
    };
    final private[this] def primaryConstructorParamNamer$1(): scala.tools.nsc.typechecker.Namer = {
      val classContext: scala.tools.nsc.typechecker.Context = Namer.this.context().enclClass();
      val paramContext$1: scala.tools.nsc.typechecker.Context = Namer.this.makeConstructorScope(classContext);
      val unsafeTypeParams: List = Namer.this.context().owner().unsafeTypeParams();
      unsafeTypeParams.foreach((new /*anonymous class*/ $anonfun$primaryConstructorParamNamer$1$1(Namer.this, paramContext$1): Function1));
      Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().newNamer(paramContext$1)
    };
    final private[this] def usePrimary$1(sym$1: scala.tools.nsc.symtab.Symbol): Boolean = sym$1.isTerm().&&(sym$1.hasFlag(536870912L).||(sym$1.hasFlag(8192L).&&(sym$1.owner().isPrimaryConstructor())));
    final private[this] def copyIsSynthetic$1(sym$2: scala.tools.nsc.symtab.Symbol): Boolean = sym$2.owner().info().member(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().nme().copy()).hasFlag(2097152L);
    final private[this] def finishWith$1(tparams: List, tree$1: scala.tools.nsc.ast.Tree): Unit = Namer.this.enterSymFinishWith(tree$1, tparams);
    final private[this] def finish$1(tree$1: scala.tools.nsc.ast.Tree): Unit = Namer.this.finishWith$1(immutable.this.Nil, tree$1);
    final private[this] def sym$4(tree$1: scala.tools.nsc.ast.Tree): scala.tools.nsc.symtab.Symbol = tree$1.symbol();
    final def isAnn$1(ann: scala.tools.nsc.ast.Tree, demand: java.lang.String): Boolean = {
      var temp74: scala.tools.nsc.ast.Tree = ann;
      if (temp74.$isInstanceOf[scala.tools.nsc.ast.Apply]())
        {
          var temp75: scala.tools.nsc.ast.Apply = temp74.$asInstanceOf[scala.tools.nsc.ast.Apply]();
          var temp76: scala.tools.nsc.ast.Tree = temp75.fun();
          if (temp76.$isInstanceOf[scala.tools.nsc.ast.Select]())
            {
              var temp78: scala.tools.nsc.ast.Select = temp76.$asInstanceOf[scala.tools.nsc.ast.Select]();
              var temp79: scala.tools.nsc.ast.Tree = temp78.qualifier();
              if (temp79.$isInstanceOf[scala.tools.nsc.ast.New]())
                {
                  var temp81: scala.tools.nsc.ast.New = temp79.$asInstanceOf[scala.tools.nsc.ast.New]();
                  var temp82: scala.tools.nsc.ast.Tree = temp81.tpt();
                  if (temp82.$isInstanceOf[scala.tools.nsc.ast.Ident]())
                    {
                      var temp83: scala.tools.nsc.ast.Ident = temp82.$asInstanceOf[scala.tools.nsc.ast.Ident]();
                      var temp84: scala.tools.nsc.symtab.Name = temp83.name();
                      {
                        val name: scala.tools.nsc.symtab.Name = temp84;
                        val name: scala.tools.nsc.symtab.Name = temp84;
                        // @todo check -- LabelDef 
                        body_0: 
                        /*(name)*/{
                          name.toString().==(demand)
                        };
                        /*EmptyTree*/
                      };
                      /*EmptyTree*/
                    }
                  else
                    if (temp82.$isInstanceOf[scala.tools.nsc.ast.Select]())
                      {
                        var temp85: scala.tools.nsc.ast.Select = temp82.$asInstanceOf[scala.tools.nsc.ast.Select]();
                        var temp86: scala.tools.nsc.ast.Tree = temp85.qualifier();
                        {
                          var temp87: scala.tools.nsc.symtab.Name = temp85.name();
                          {
                            val name: scala.tools.nsc.symtab.Name = temp87;
                            val pre: scala.tools.nsc.ast.Tree = temp86;
                            {
                              val pre: scala.tools.nsc.ast.Tree = temp86;
                              val name: scala.tools.nsc.symtab.Name = temp87;
                              // @todo check -- LabelDef 
                              body_1: 
                              /*(pre,name)*/{
                                name.toString().==(demand)
                              };
                              /*EmptyTree*/
                            };
                            /*EmptyTree*/
                          };
                          /*EmptyTree*/
                        };
                        /*EmptyTree*/
                      }
                    else
                      false;
                  /*EmptyTree*/
                }
              else
                false;
              /*EmptyTree*/
            }
          else
            false;
          /*EmptyTree*/
        }
      else
        false
    };
    final private[this] def isHidden$1(tp: scala.tools.nsc.symtab.Type, getter$1: scala.tools.nsc.symtab.Symbol): Boolean = {
      /*synthetic*/ val _$this: scala.tools.nsc.typechecker.Namer = Namer.this;
      do
        var temp102: scala.tools.nsc.symtab.Type = tp
      while (temp102.$isInstanceOf[scala.tools.nsc.symtab.SingleType]())
      
    };
    final def enterValueParam$1(param: scala.tools.nsc.ast.ValDef, owner$1: scala.tools.nsc.symtab.Symbol): scala.tools.nsc.symtab.Symbol = {
      param.symbol_=(Namer.this.setInfo(Namer.this.enterInScope({
        val sym: scala.tools.nsc.symtab.TermSymbol = owner$1.newValueParameter(param.pos(), param.name()).setFlag(param.mods().flags().&(33620480)).$asInstanceOf[scala.tools.nsc.symtab.TermSymbol]();
        Namer.this.setPrivateWithin(param, sym, param.mods())
      }), Namer.this.typeCompleter(param)));
      param.symbol()
    };
    final def checkParent$1(tpt: scala.tools.nsc.ast.Tree): scala.tools.nsc.symtab.Type = {
      val tp: scala.tools.nsc.symtab.Type = tpt.tpe();
      if (tp.typeSymbol().==(Namer.this.context().owner()))
        {
          Namer.this.context().error(tpt.pos(), "".+(tp.typeSymbol()).+(" inherits itself"));
          Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().definitions().AnyRefClass().tpe()
        }
      else
        if (tp.isError())
          Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().definitions().AnyRefClass().tpe()
        else
          tp
    };
    final private[this] def enterSelf$1(self: scala.tools.nsc.ast.ValDef, clazz$1: scala.tools.nsc.symtab.Symbol): Unit = {
      if (self.tpt().isEmpty().unary_!())
        {
          clazz$1.typeOfThis_=(Namer.this.selfTypeCompleter(self.tpt()));
          self.symbol_=(clazz$1.thisSym().setPos(self.pos()))
        }
      else
        {
          self.tpt().defineType(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().NoType());
          if (self.name().!=(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().nme().WILDCARD()))
            {
              clazz$1.typeOfThis_=(clazz$1.tpe());
              self.symbol_=(clazz$1.thisSym())
            }
          else
            if (self.ne(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().emptyValDef()))
              self.symbol_=(clazz$1.newThisSym(self.pos()).setInfo(clazz$1.tpe()))
            else
              ()
        };
      if (self.name().!=(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().nme().WILDCARD()))
        {
          self.symbol().name_=(self.name());
          self.symbol_=(Namer.this.context().scope().enter(self.symbol()))
        }
      else
        ()
    };
    final def hasCopy$1(decls: scala.tools.nsc.symtab.Scope): Boolean = decls.iterator().exists((new /*anonymous class*/ $anonfun$hasCopy$1$1(Namer.this): Function1));
    final def convertToDeBruijn$1(vparams$1: List, level$1: Int, meth$1: scala.tools.nsc.symtab.Symbol): scala.tools.nsc.symtab.TypeMap = new /*anonymous class*/ $anon$4(Namer.this, meth$1, vparams$1, level$1);
    final def makeMethodType$1(vparams: List, restpe: scala.tools.nsc.symtab.Type, meth$1: scala.tools.nsc.symtab.Symbol): scala.tools.nsc.symtab.MethodType = {
      val params: List = vparams.map((new /*anonymous class*/ $anonfun$12(Namer.this, meth$1): Function1), immutable.this.List.canBuildFrom()).$asInstanceOf[List]();
      val restpe1: scala.tools.nsc.symtab.Type = Namer.this.convertToDeBruijn$1(vparams, 1, meth$1).apply(restpe).$asInstanceOf[scala.tools.nsc.symtab.Type]();
      if (vparams.isEmpty().unary_!().&&(vparams.head().$asInstanceOf[scala.tools.nsc.symtab.Symbol]().hasFlag(512L)))
        Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().ImplicitMethodType(params, restpe1)
      else
        if (meth$1.hasFlag(1048576L))
          Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().JavaMethodType(params, restpe1)
        else
          new scala.tools.nsc.symtab.MethodType(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global(), params, restpe1)
    };
    final def thisMethodType$1(restpe: scala.tools.nsc.symtab.Type, meth$1: scala.tools.nsc.symtab.Symbol, tparamSyms$1: List, vparamSymss$1: scala.runtime.ObjectRef, checkDependencies$1: scala.tools.nsc.symtab.TypeTraverser): scala.tools.nsc.symtab.Type = Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().polyType(tparamSyms$1, if (vparamSymss$1.elem.$asInstanceOf[List]().isEmpty())
      new scala.tools.nsc.symtab.PolyType(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global(), immutable.this.Nil, restpe)
    else
      checkDependencies$1.apply(vparamSymss$1.elem.$asInstanceOf[List]().:\(restpe, (new /*anonymous class*/ $anonfun$thisMethodType$1$1(Namer.this, meth$1): Function2)).$asInstanceOf[scala.tools.nsc.symtab.Type]()));
    final def overriddenSymbol$1(tparams$3: List, meth$1: scala.tools.nsc.symtab.Symbol, tparamSyms$1: List, vparamSymss$1: scala.runtime.ObjectRef, checkDependencies$1: scala.tools.nsc.symtab.TypeTraverser, resultPt$1: scala.runtime.ObjectRef, site$1: scala.tools.nsc.symtab.Type): scala.tools.nsc.symtab.Symbol = Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().intersectionType(meth$1.owner().info().parents()).member(meth$1.name()).filter((new /*anonymous class*/ $anonfun$overriddenSymbol$1$1(Namer.this, tparams$3, meth$1, tparamSyms$1, vparamSymss$1, checkDependencies$1, resultPt$1, site$1): Function1));
    final /*synthetic*/ private[this] def gd5$1(x$1: scala.tools.nsc.symtab.Type, x$2: scala.tools.nsc.symtab.Type): Boolean = x$1.isError().||(x$2.isError());
    final /*synthetic*/ private[this] def gd6$1(x$1: scala.tools.nsc.symtab.TypeBounds, x$2: scala.tools.nsc.symtab.Type, x$3: scala.tools.nsc.symtab.Type, tpsym$1: scala.tools.nsc.symtab.Symbol): Boolean = tpsym$1.hasFlag(1048576L);
    final def verifyOverriding$1(other: scala.tools.nsc.symtab.Symbol, tpsym$1: scala.tools.nsc.symtab.Symbol, tparamSyms$2: List): Boolean = if (other.unsafeTypeParams().length().!=(tparamSyms$2.length()))
      {
        Namer.this.context().error(tpsym$1.pos(), "The kind of ".+(tpsym$1.keyString()).+(" ").+(tpsym$1.varianceString()).+(tpsym$1.nameString()).+(" does not conform to the expected kind of ").+(other.defString()).+(other.locationString()).+("."));
        false
      }
    else
      true;
    final private[this] def warnRedundant$1(sym: scala.tools.nsc.symtab.Symbol, pos$1: scala.tools.nsc.util.Position, to$1: scala.tools.nsc.symtab.Name): Unit = Namer.this.context().unit().warning(pos$1, "imported `".+(to$1).+("' is permanently hidden by definition of ").+(sym).+(sym.locationString()));
    final private[this] def checkNotRedundant$1(pos$1: scala.tools.nsc.util.Position, from: scala.tools.nsc.symtab.Name, to$1: scala.tools.nsc.symtab.Name, tree$4: scala.tools.nsc.ast.Tree, expr1$1: scala.tools.nsc.ast.Tree, base$1: scala.tools.nsc.symtab.Type): Boolean = {
      if (tree$4.symbol().hasFlag(2097152L).unary_!().&&(expr1$1.symbol().ne(null).&&(expr1$1.symbol().isInterpreterWrapper()).unary_!()).&&(base$1.member(from).!=(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().NoSymbol())))
        {
          val e: scala.tools.nsc.symtab.ScopeEntry = Namer.this.context().scope().lookupEntry(to$1);
          if (e.ne(null).&&(e.owner().==(Namer.this.context().scope())).&&(e.sym().exists()))
            {
              Namer.this.warnRedundant$1(e.sym(), pos$1, to$1);
              return false
            }
          else
            if (Namer.this.context().eq(Namer.this.context().enclClass()))
              {
                val defSym: scala.tools.nsc.symtab.Symbol = Namer.this.context().prefix().member(to$1).filter((new /*anonymous class*/ $anonfun$23(Namer.this): Function1));
                if (defSym.!=(Namer.this.scala$tools$nsc$typechecker$Namers$Namer$$$outer().global().NoSymbol()))
                  {
                    Namer.this.warnRedundant$1(defSym, pos$1, to$1);
                    return false
                  }
                else
                  ()
              }
            else
              ()
        }
      else
        ();
      true
    };
    final private[this] def checkSelectors$1(selectors: List, tree$4: scala.tools.nsc.ast.Tree, expr$1: scala.tools.nsc.ast.Tree, expr1$1: scala.tools.nsc.ast.Tree, base$1: scala.tools.nsc.symtab.Type): Unit = {
      /*synthetic*/ val _$this: scala.tools.nsc.typechecker.Namer = Namer.this;
      do
        val temp175: List = selectors
      while (temp175.$isInstanceOf[scala.collection.immutable.::]())
      
    };
    final /*synthetic*/ private[this] def gd7$1(x$1: List, x$2: scala.tools.nsc.symtab.Type): Boolean = x$1.isEmpty().unary_!().&&(x$1.head().$asInstanceOf[scala.tools.nsc.symtab.Symbol]().owner().isTerm()).||(x$1.exists((new /*anonymous class*/ $anonfun$gd7$1$1(Namer.this): Function1)));
    final private[this] def checkNoConflict$1(flag1: Int, flag2: Int, sym$3: scala.tools.nsc.symtab.Symbol): Unit = if (sym$3.hasFlag(flag1.toLong()).&&(sym$3.hasFlag(flag2.toLong())))
      Namer.this.context().error(sym$3.pos(), if (flag1.==(16))
        "abstract member may not have ".+(symtab.Flags.flagsToString(flag2.toLong())).+(" modifier")
      else
        "illegal combination of modifiers: ".+(symtab.Flags.flagsToString(flag1.toLong())).+(" and ").+(symtab.Flags.flagsToString(flag2.toLong())).+(" for: ").+(sym$3))
    else
      ();
    def this($outer: scala.tools.nsc.typechecker.Analyzer, context: scala.tools.nsc.typechecker.Context): scala.tools.nsc.typechecker.Namer = {
      Namer.this.context = context;
      if ($outer.eq(null))
        throw new java.lang.NullPointerException()
      else
        Namer.this.$outer = $outer;
      Namer.super.this();
      Namer.this.typer = $outer.newTyper(context);
      Namer.this.innerNamerCache = null;
      ()
    }
  };
  abstract class TypeCompleter extends scala.tools.nsc.symtab.LazyType with ScalaObject {
    /*stable*/ /*accessor*/ def tree(): scala.tools.nsc.ast.Tree;
    protected /*synthetic*/ /*paramaccessor*/ val $outer: scala.tools.nsc.typechecker.Analyzer = _;
    /*synthetic*/ /*stable*/ def scala$tools$nsc$typechecker$Namers$TypeCompleter$$$outer(): scala.tools.nsc.typechecker.Analyzer = TypeCompleter.this.$outer;
    def this($outer: scala.tools.nsc.typechecker.Analyzer): scala.tools.nsc.typechecker.TypeCompleter = {
      if ($outer.eq(null))
        throw new java.lang.NullPointerException()
      else
        TypeCompleter.this.$outer = $outer;
      TypeCompleter.super.this($outer.global());
      ()
    }
  };
  @SerialVersionUID(0) @serializable 
  final /*synthetic*/ class $anonfun$24 extends scala.runtime.AbstractFunction1 {
    final def apply(x$33: scala.tools.nsc.ast.Tree): scala.tools.nsc.symtab.Symbol = x$33.symbol();
    final /*bridge*/ def apply(v1: java.lang.Object): java.lang.Object = $anonfun$24.this.apply(v1.$asInstanceOf[scala.tools.nsc.ast.Tree]());
    def this($outer: scala.tools.nsc.typechecker.PolyTypeCompleter): /*anonymous class*/ $anonfun$24 = {
      $anonfun$24.super.this();
      ()
    }
  };
  class PolyTypeCompleter extends scala.tools.nsc.typechecker.TypeCompleter with ScalaObject {
    /*paramaccessor*/ private[this] val tparams: List = _;
    /*paramaccessor*/ private[this] val restp: scala.tools.nsc.typechecker.TypeCompleter = _;
    /*paramaccessor*/ private[this] val owner: scala.tools.nsc.ast.Tree = _;
    /*paramaccessor*/ private[this] val ownerSym: scala.tools.nsc.symtab.Symbol = _;
    /*paramaccessor*/ private[this] val ctx: scala.tools.nsc.typechecker.Context = _;
    private[this] val typeParams: List = _;
    override /*stable*/ /*accessor*/ def typeParams(): List = PolyTypeCompleter.this.typeParams;
    private[this] val tree: scala.tools.nsc.ast.Tree = _;
    override /*stable*/ /*accessor*/ def tree(): scala.tools.nsc.ast.Tree = PolyTypeCompleter.this.tree;
    override def complete(sym: scala.tools.nsc.symtab.Symbol): Unit = {
      if (PolyTypeCompleter.this.ownerSym.isAbstractType())
        PolyTypeCompleter.this.scala$tools$nsc$typechecker$Namers$PolyTypeCompleter$$$outer().newNamer(PolyTypeCompleter.this.ctx.makeNewScope(PolyTypeCompleter.this.owner, PolyTypeCompleter.this.ownerSym)).enterSyms(PolyTypeCompleter.this.tparams)
      else
        scala.runtime.BoxedUnit.UNIT;
      PolyTypeCompleter.this.restp.complete(sym)
    };
    /*synthetic*/ /*stable*/ def scala$tools$nsc$typechecker$Namers$PolyTypeCompleter$$$outer(): scala.tools.nsc.typechecker.Analyzer = PolyTypeCompleter.this.$outer;
    def this($outer: scala.tools.nsc.typechecker.Analyzer, tparams: List, restp: scala.tools.nsc.typechecker.TypeCompleter, owner: scala.tools.nsc.ast.Tree, ownerSym: scala.tools.nsc.symtab.Symbol, ctx: scala.tools.nsc.typechecker.Context): scala.tools.nsc.typechecker.PolyTypeCompleter = {
      PolyTypeCompleter.this.tparams = tparams;
      PolyTypeCompleter.this.restp = restp;
      PolyTypeCompleter.this.owner = owner;
      PolyTypeCompleter.this.ownerSym = ownerSym;
      PolyTypeCompleter.this.ctx = ctx;
      PolyTypeCompleter.super.this($outer);
      PolyTypeCompleter.this.typeParams = tparams.map((new /*anonymous class*/ $anonfun$24(PolyTypeCompleter.this): Function1), immutable.this.List.canBuildFrom()).$asInstanceOf[List]();
      PolyTypeCompleter.this.tree = restp.tree();
      ()
    }
  };
  final class $anon$1 extends scala.tools.nsc.typechecker.TypeCompleter {
    private[this] val tree: scala.tools.nsc.ast.Tree = _;
    /*stable*/ /*accessor*/ def tree(): scala.tools.nsc.ast.Tree = $anon$1.this.tree;
    override def complete(sym: scala.tools.nsc.symtab.Symbol): Unit = {
      $anon$1.this.c$1.apply(sym);
      ()
    };
    /*synthetic*/ /*paramaccessor*/ private[this] val c$1: Function1 = _;
    def this($outer: scala.tools.nsc.typechecker.Analyzer, t$1: scala.tools.nsc.ast.Tree, c$1: Function1): /*anonymous class*/ $anon$1 = {
      $anon$1.this.c$1 = c$1;
      $anon$1.super.this($outer);
      $anon$1.this.tree = t$1;
      ()
    }
  }
}
}