scala v2.10.0-M6 comments

odersky.txt

./src/compiler/scala/tools/nsc/ast/parser/Parsers.scala:2247:          val tparams = typeParamClauseOpt(pname, null) // @M TODO null --> no higher-order context bounds for now
./src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala:844:    // @M don't generate java generics sigs for (members of) implementation
./src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala:721:    // @M don't generate java generics sigs for (members of) implementation
./src/compiler/scala/tools/nsc/typechecker/Contexts.scala:585://@M TODO: when higher-kinded types are inferred, probably need a case PolyType(_, TypeBounds(...)) if ... =>
./src/compiler/scala/tools/nsc/typechecker/Infer.scala:209:      // later whether it works.  *ZAP* @M danger, Will Robinson! this means
./src/compiler/scala/tools/nsc/typechecker/Infer.scala:1000:      //@M validate variances & bounds of targs wrt variances & bounds of tparams
./src/compiler/scala/tools/nsc/typechecker/Infer.scala:1001:      //@M TODO: better place to check this?
./src/compiler/scala/tools/nsc/typechecker/Infer.scala:1002:      //@M TODO: errors for getters & setters are reported separately
./src/compiler/scala/tools/nsc/typechecker/Namers.scala:517:        //@M e.g., in [A[x <: B], B], A and B are entered first as both are in scope in the definition of x
./src/compiler/scala/tools/nsc/typechecker/Namers.scala:518:        //@M x is only in scope in `A[x <: B]'
./src/compiler/scala/tools/nsc/typechecker/Namers.scala:519:        if (!tree.symbol.isAbstractType) //@M TODO: change to isTypeMember ?
./src/compiler/scala/tools/nsc/typechecker/Namers.scala:1150:      val tparamSyms = typer.reenterTypeParams(tparams) //@M make tparams available in scope (just for this abstypedef)
./src/compiler/scala/tools/nsc/typechecker/Namers.scala:1474:      // @M an abstract type's type parameters are entered.
./src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala:454:      //@M note that we don't get here when an ambiguity was detected (during the computation of res),
./src/compiler/scala/tools/nsc/typechecker/RefChecks.scala:923:            // @M for higher-kinded typeref, args.isEmpty
./src/compiler/scala/tools/nsc/typechecker/Typers.scala:311:          // @M was: checkNonCyclic(pos, pre.memberInfo(sym).subst(sym.typeParams, args), sym)
./src/compiler/scala/tools/nsc/typechecker/Typers.scala:919:          // @M When not typing a higher-kinded type ((mode & HKmode) == 0)
./src/compiler/scala/tools/nsc/typechecker/Typers.scala:922:          // @M TODO: why do kind-* tree's have symbols, while higher-kinded ones don't?
./src/compiler/scala/tools/nsc/typechecker/Typers.scala:1086:          // assert((mode & HKmode) == 0) //@M a PolyType in HKmode represents an anonymous type function,
./src/compiler/scala/tools/nsc/typechecker/Typers.scala:3650:        val tparams = fun.symbol.typeParams //@M TODO: fun.symbol.info.typeParams ? (as in typedAppliedTypeTree)
./src/compiler/scala/tools/nsc/typechecker/Typers.scala:3677:            //@M substitution in instantiateParams needs to be careful!
./src/compiler/scala/tools/nsc/typechecker/Typers.scala:3678:            //@M example: class Foo[a] { def foo[m[x]]: m[a] = error("") } (new Foo[Int]).foo[List] : List[Int]
./src/compiler/scala/tools/nsc/typechecker/Typers.scala:3679:            //@M    --> first, m[a] gets changed to m[Int], then m gets substituted for List,
./src/compiler/scala/tools/nsc/typechecker/Typers.scala:3681:            //@M related bug: #1438
./src/compiler/scala/tools/nsc/typechecker/Typers.scala:5020:          // @M TODO: the compiler still bootstraps&all tests pass when this is commented out..
./src/compiler/scala/tools/nsc/typechecker/Typers.scala:5027:          //@M TODO: val undets_fun = context.undetparams  ?
./src/compiler/scala/tools/nsc/typechecker/Typers.scala:5030:          // @M TODO: the compiler still bootstraps when this is commented out.. TODO: run tests
./src/compiler/scala/tools/nsc/typechecker/Typers.scala:5033:          // @M maybe the well-kindedness check should be done when checking the type arguments conform to the type parameters' bounds?
./src/compiler/scala/tools/nsc/typechecker/Typers.scala:5038:                      //@M  this branch is correctly hit for an overloaded polymorphic type. It also has to handle erroneous cases.
./src/compiler/scala/tools/nsc/typechecker/Typers.scala:5047:          //@M TODO: context.undetparams = undets_fun ?
./src/compiler/scala/tools/nsc/typechecker/Typers.scala:5252:          if (settings.debug.value) // @M causes cyclic reference error
./src/compiler/scala/tools/nsc/typechecker/Typers.scala:5364:	      //@M fix for #2208
./src/reflect/scala/reflect/internal/Kinds.scala:35:    // @M TODO this method is duplicated all over the place (varianceString)
./src/reflect/scala/reflect/internal/Kinds.scala:110:   *   - @M TODO: are these conditions correct,sufficient&necessary?
./src/reflect/scala/reflect/internal/Kinds.scala:139:      // @M sometimes hkargs != arg.typeParams, the symbol and the type may
./src/reflect/scala/reflect/internal/Kinds.scala:214:        // @M must use the typeParams of the *type* targ, not of the *symbol* of targ!!
./src/reflect/scala/reflect/internal/Symbols.scala:1381:     *    @M you should use tpeHK for a type symbol with type parameters if
./src/reflect/scala/reflect/internal/Symbols.scala:2876:    /** @M -- tpe vs tpeHK:
./src/reflect/scala/reflect/internal/transform/Erasure.scala:62:  // @M #2585 when generating a java generic signature that includes
./src/reflect/scala/reflect/internal/TypeDebugging.scala:14:  // @M toString that is safe during debugging (does not normalize, ...)
./src/reflect/scala/reflect/internal/Types.scala:324:    /** Is this type higher-kinded, i.e., is it a type constructor @M */
./src/reflect/scala/reflect/internal/Types.scala:481:    /** This type, without its type arguments @M */
./src/reflect/scala/reflect/internal/Types.scala:737:    def computeMemberType(sym: Symbol): Type = sym.tpeHK match { //@M don't prematurely instantiate higher-kinded types, they will be instantiated by transform, typedTypeApply, etc. when really necessary
./src/reflect/scala/reflect/internal/Types.scala:1722:    //@M may result in an invalid type (references to higher-order args become dangling )
./src/reflect/scala/reflect/internal/Types.scala:3278:        TypeVar(origin, constr cloneInternal, typeArgs, params) // @M TODO: clone args/params?
./src/reflect/scala/reflect/internal/Types.scala:3592:      case TypeRef(pre, sym @ (NothingClass|AnyClass), _) => copyTypeRef(tycon, pre, sym, Nil)   //@M drop type args to Any/Nothing
./src/reflect/scala/reflect/internal/Types.scala:3596:      case st: SingletonType                              => appliedType(st.widen, args) // @M TODO: what to do? see bug1
./src/reflect/scala/reflect/internal/Types.scala:3737:  def abstractTypesToBounds(tp: Type): Type = tp match { // @M don't normalize here (compiler loops on pos/bug1090.scala )
./src/reflect/scala/reflect/internal/Types.scala:3903:    var inst: Type = NoType // @M reduce visibility?
./src/reflect/scala/reflect/internal/Types.scala:4102:        else tv.applyArgs(mapOverArgs(tv.typeArgs, tv.params))  //@M !args.isEmpty implies !typeParams.isEmpty
./src/reflect/scala/reflect/internal/Types.scala:5324:        (tparams1.length == tparams2.length) && (tparams1 corresponds tparams2)(_.info =:= _.info.substSym(tparams2, tparams1)) && // @M looks like it might suffer from same problem as #2210
./src/reflect/scala/reflect/internal/Types.scala:5327:        (tparams1.length == tparams2.length) && (tparams1 corresponds tparams2)(_.info =:= _.info.substSym(tparams2, tparams1)) && // @M looks like it might suffer from same problem as #2210
./src/reflect/scala/reflect/internal/Types.scala:5465:              // @M looks like it might suffer from same problem as #2210
./src/reflect/scala/reflect/internal/Types.scala:5476:            // @M looks like it might suffer from same problem as #2210
./src/reflect/scala/reflect/internal/Types.scala:5636:    tp2.typeSymbol == AnyClass // @M Any and Nothing are super-type resp. subtype of every well-kinded type
./src/reflect/scala/reflect/internal/Types.scala:5645:            //@M for an example of why we need to generate fresh symbols, see neg/tcpoly_ticket2101.scala
./src/reflect/scala/reflect/internal/Types.scala:5652:            //@M the forall in the previous test could be optimised to the following,
./src/reflect/scala/reflect/internal/Types.scala:6775:                       // if(!(tparam.info.bounds contains tparam))   //@M can't deal with f-bounds, see #2251
./test/files/neg/tcpoly_ticket2101.scala:24://      val tpsFresh = cloneSymbols(tparams1) // @M cloneSymbols(tparams2) should be equivalent -- TODO: check

paulp.txt

./src/compiler/scala/reflect/reify/utils/NodePrinters.scala:22:      // @PP: I fervently hope this is a test case or something, not anything being
./src/compiler/scala/tools/nsc/transform/Mixin.scala:938:                  // @PP: It does not seem so, it crashes for me trying to bootstrap.
./src/compiler/scala/tools/nsc/typechecker/Namers.scala:107:    // @PP: ...or fields declared as private[this].  PARAMACCESSOR marks constructor arguments.
./src/compiler/scala/tools/nsc/typechecker/Namers.scala:402:      // @PP: I tried to reverse engineer said documentation.  The only tests
./src/compiler/scala/tools/nsc/typechecker/Namers.scala:1436:      // @PP: I added this as a sanity check because these flags are supposed to be
./src/compiler/scala/tools/nsc/typechecker/Typers.scala:2847:          // @PP responds: I changed it to pass WildcardType instead of pt and only one line in
./src/compiler/scala/tools/nsc/typechecker/Typers.scala:4075:                        .setType(appliedType(tpt0.tpe, context.undetparams map (_.tpeHK))) // @PP: tpeHK! #3343, #4018, #4347.
./src/library/scala/Array.scala:425:    // in pattern matcher.  @PP: I noted in #4364 I think the behavior is correct.
./src/library/scala/reflect/base/Trees.scala:923:   *  @PP: All signs point toward it being a requirement that args.nonEmpty,
./src/reflect/scala/reflect/internal/Positions.scala:43:        // @PP: it's pruning whenever it encounters a node with a
./src/reflect/scala/reflect/internal/transform/Erasure.scala:183:   *      - in java, the erasure of its first parent                  <--- @PP: not yet in spec.
./src/reflect/scala/reflect/internal/transform/Erasure.scala:295:   *    type parameter of intersectionDominator(List(El1, El2, ...)).           <--- @PP: not yet in spec.
./src/reflect/scala/reflect/internal/transform/Erasure.scala:300:   *    not Object, the dominator is Tc.                                        <--- @PP: "which is not Object" not in spec.
./src/reflect/scala/reflect/internal/Types.scala:3021:    // !!! @PP - I need an example of this, since this exception never triggers
./src/reflect/scala/reflect/internal/Types.scala:3182:              // @PP: Is it going to be faster to filter out the parents we just checked?
./src/reflect/scala/reflect/internal/Types.scala:3832:  /** @PP: Unable to see why these apparently constant types should need vals
./src/reflect/scala/reflect/internal/Types.scala:4224:   *  @PP: Commenting out due to not being used anywhere.
./src/reflect/scala/reflect/internal/Types.scala:4713:      // @PP: That leads to failure here, where stuff no longer has type
./src/reflect/scala/reflect/internal/Types.scala:4721:      // @PP: In the following:
./src/reflect/scala/reflect/makro/Universe.scala:62:     *  @PP: Attempting to elaborate on the above, I find: If defineType

VladUreche.txt

./src/compiler/scala/tools/nsc/doc/html/page/Template.scala:959:  /* Vlad: Lesson learned the hard way: don't put any stateful code that references the model here,
./src/compiler/scala/tools/nsc/doc/model/diagram/DiagramDirectiveParser.scala:29:   *  Vlad: There's an explanation I owe to people using diagrams and not finding a way to hide a specific class from
./src/compiler/scala/tools/nsc/doc/model/ModelFactoryImplicitSupport.scala:355:      // @Vlad: I'm being extra conservative in template creation -- I don't want to create templates for complex types
./src/compiler/scala/tools/nsc/doc/model/ModelFactoryImplicitSupport.scala:598:    // Vlad: I tried using matches but it's not exactly what we need:
./test/scaladoc/resources/implicits-base-res.scala:144:// [Eugene to Vlad] how do I test typetags here?

xeno-by.txt

./src/compiler/scala/reflect/makro/runtime/Infrastructure.scala:    // [Eugene] a heuristic to detect REPL
./src/compiler/scala/reflect/makro/runtime/Settings.scala:    // [Eugene] what settings should we exclude?
./src/compiler/scala/reflect/makro/util/Traces.scala:  // [Eugene] lots of ways to log:
./src/compiler/scala/reflect/reify/codegen/GenTypes.scala:    // [Eugene] how do I check that the substitution is legal w.r.t tpe.info?
./src/compiler/scala/reflect/reify/codegen/GenTypes.scala:    // [Eugene] it seems that depending on the context the very same symbol can be either a spliceable tparam or a quantified existential. very weird!
./src/compiler/scala/reflect/reify/phases/Calculate.scala:    def isLocalToReifee = (localSymbols contains sym) // [Eugene] how do I account for local skolems?
./src/compiler/scala/reflect/reify/phases/Reshape.scala:    // [Eugene] is this implemented correctly?
./src/compiler/scala/reflect/reify/Reifier.scala:      // [Eugene] conventional way of doing this?
./src/compiler/scala/reflect/reify/Reifier.scala:          // [Eugene] conventional way of doing this?
./src/compiler/scala/reflect/reify/Reifier.scala:      // [Eugene++] yeah, ugly and extremely brittle, but we do need to do resetAttrs. will be fixed later
./src/compiler/scala/reflect/reify/utils/NodePrinters.scala:      // @Eugene: This stuff is only needed to debug-print out reifications in human-readable format
./src/compiler/scala/reflect/reify/utils/SymbolTables.scala:             // [Eugene] better to have a symbol without a type signature, than to crash with a CyclicReference
./src/compiler/scala/tools/nsc/ast/NodePrinters.scala:      // [Eugene++] there's most likely a bug here (?)
./src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala:              // [Eugene++] no longer compiles after I moved the `Ident` case class into scala.reflect.internal
./src/compiler/scala/tools/nsc/ast/Positions.scala:  // [Eugene] disabling this for now. imo it doesn't justify pollution of the public API
./src/compiler/scala/tools/nsc/ast/Trees.scala:        // [Eugene++] no longer compiles after I moved the `Apply` case class into scala.reflect.internal
./src/compiler/scala/tools/nsc/doc/model/ModelFactoryImplicitSupport.scala:        newContext.macrosEnabled = false // [Eugene] I assume you want macro signature, not macro expansion
./src/compiler/scala/tools/nsc/Global.scala:  // [Eugene++] would love to find better homes for the new things dumped into Global
./src/compiler/scala/tools/nsc/Global.scala:  // [Eugene++] this little inconvenience gives us precise types for Expr.mirror and TypeTag.mirror
./src/compiler/scala/tools/nsc/Global.scala:    // [Eugene++ to Martin] please, verify
./src/compiler/scala/tools/nsc/Global.scala:          // [Eugene++ to Martin] please, verify
./src/compiler/scala/tools/nsc/Global.scala:        // [Eugene++ to Martin] please, verify
./src/compiler/scala/tools/nsc/interpreter/IMain.scala:      // [Eugene] todo. if this crashes, REPL will hang
./src/compiler/scala/tools/nsc/interpreter/IMain.scala:        // [Eugene to Paul] previously it just said `t map ...`
./src/compiler/scala/tools/nsc/interpreter/IMain.scala:  // [Eugene to Paul] possibly you could make use of TypeTags here
./src/compiler/scala/tools/nsc/interpreter/Power.scala:    // [Eugene to Paul] needs review!
./src/compiler/scala/tools/nsc/interpreter/TypeStrings.scala:    // [Eugene++ to Paul] needs review!!
./src/compiler/scala/tools/nsc/interpreter/TypeStrings.scala:    // [Eugene++] todo. need to use not the `rootMirror`, but a mirror with the REPL's classloader
./src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala:      tparam.cloneSymbol(sClass, tparam.flags, (tparam.name append tpnme.SPECIALIZED_SUFFIX).asInstanceOf[Name]) // [Eugene++] why do we need this cast?
./src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala:    // [Eugene++] no longer compiles after I moved the `Apply` case class into scala.reflect.internal
./src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala:    // [Eugene++] no longer compiles after I moved the `Apply` case class into scala.reflect.internal
./src/compiler/scala/tools/nsc/typechecker/Implicits.scala:          // [Eugene] very unreliable, ask Hubert about a better way
./src/compiler/scala/tools/nsc/typechecker/Implicits.scala:          // [Eugene to Martin] this is the crux of the interaction between
./src/compiler/scala/tools/nsc/typechecker/Implicits.scala:     *  // [Eugene] the following lines should be deleted after we migrate delegate tag materialization to implicit macros
./src/compiler/scala/tools/nsc/typechecker/Infer.scala:            // [Eugene] is there a better way?
./src/compiler/scala/tools/nsc/typechecker/Macros.scala:          // [Eugene] deskolemization became necessary once I implemented inference of macro def return type
./src/compiler/scala/tools/nsc/typechecker/Macros.scala:        val prevNumErrors = reporter.ERROR.count // [Eugene] funnily enough, the isErroneous check is not enough
./src/compiler/scala/tools/nsc/typechecker/Macros.scala:        // [Eugene] not sure which of these deSkolemizes are necessary
./src/compiler/scala/tools/nsc/typechecker/Macros.scala:      // [Eugene] a heuristic to detect the REPL
./src/compiler/scala/tools/nsc/typechecker/Macros.scala:          // [Eugene++] I don't use Scala reflection here, because it seems to interfere with JIT magic
./src/compiler/scala/tools/nsc/typechecker/Macros.scala:              // [Eugene] relies on the fact that macro implementations can only be defined in static classes
./src/compiler/scala/tools/nsc/typechecker/Macros.scala:              // [Martin to Eugene++] There's similar logic buried in Symbol#flatname. Maybe we can refactor?
./src/compiler/scala/tools/nsc/typechecker/Macros.scala:              // [Eugene++] this doesn't work for inner classes
./src/compiler/scala/tools/nsc/typechecker/Macros.scala:                // [Eugene++] doh, it seems that I need to copy/paste Scala reflection logic
./src/compiler/scala/tools/nsc/typechecker/Macros.scala:              // [Eugene] doesn't work when macro def is compiled separately from its usages
./src/compiler/scala/tools/nsc/typechecker/Macros.scala:            // [Eugene] weird situation. what's the conventional way to deal with it?
./src/compiler/scala/tools/nsc/typechecker/Macros.scala:            // [Eugene++] crashes virtpatmat:
./src/compiler/scala/tools/nsc/typechecker/Macros.scala:    // [Eugene] any ideas about how to improve this one?
./src/compiler/scala/tools/nsc/typechecker/Macros.scala:            // [Eugene] is there a better way?
./src/compiler/scala/tools/nsc/typechecker/Macros.scala:   *    1) type vars (tpe.isInstanceOf[TypeVar]) // [Eugene] this check is disabled right now, because TypeVars seem to be created from undetparams anyways
./src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala:      // [Eugene++ to Paul] needs review!!
./src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala:      // [Eugene to Paul] all right, they are now. what do you have in mind?
./src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala:    // [Eugene++] without an explicit type annotation for List, we get this:
./src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala:    // [Martin->Eugene]  !!! reinstantiate when typeables are in.
./src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala:    // [Eugene++->Martin] now this compiles, will soon check it out
./src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala:      // [Eugene++ to Paul] needs review!!
./src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala:        (acc.name == orig.name) || (acc.name startsWith (orig.name append "$").asInstanceOf[Name]) // [Eugene++] why do we need this cast?
./src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala:      forwardMethod(method, getMember(ScalaRunTimeModule, (method.name prepend "_").asInstanceOf[Name]))(mkThis :: _) // [Eugene++] why do we need this cast?
./src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala:            // [Eugene] is there a better way?
./src/compiler/scala/tools/nsc/typechecker/Typers.scala:  // [Eugene] shouldn't this be converted to resetAllAttrs?
./src/compiler/scala/tools/nsc/typechecker/Typers.scala:          // [Eugene++] the commented line below makes sense for typechecking, say, TypeApply(Ident(`some abstract type symbol`), List(...))
./src/compiler/scala/tools/nsc/typechecker/Typers.scala:        // [Eugene++] todo. investigate whether something can be done about this
./src/compiler/scala/tools/nsc/typechecker/Typers.scala:            else AnnotationInfo(annType, List(), nvPairs map {p => (p._1.asInstanceOf[Name], p._2.get)}).setOriginal(Apply(typedFun, args).setPos(ann.pos)) // [Eugene+] why do we need this cast?
./src/compiler/scala/tools/nsc/typechecker/Typers.scala:              // [Eugene] no more MaxArrayDims. ClassTags are flexible enough to allow creation of arrays of arbitrary dimensionality (w.r.t JVM restrictions)
./src/compiler/scala/tools/nsc/typechecker/Typers.scala:          // [Eugene] am I doing it right?
./src/compiler/scala/tools/reflect/StdTags.scala:// [Eugene++] Before 2.10 is released, I suggest we don't rely on automated type tag generation
./src/compiler/scala/tools/reflect/ToolBoxFactory.scala:// [Eugene++ to Martin] by the way, toolboxes are unable to compile anything that involves packages
./src/compiler/scala/tools/reflect/ToolBoxFactory.scala:        // [Eugene] how can we implement that?
./src/compiler/scala/tools/reflect/ToolBoxFactory.scala:            // [Eugene] conventional way of doing this?
./src/compiler/scala/tools/reflect/ToolBoxFactory.scala:        // @Eugene writes: this dates back to the days when one could only reify functions
./src/compiler/scala/tools/reflect/ToolBoxFactory.scala:        // @Eugene writes: anyways, I'll stash the old sources here in comments in case anyone wants to revive them
./src/library/scala/reflect/base/Base.scala:  // [Eugene++] to be removed after SI-5863 is fixed
./src/library/scala/reflect/base/BuildUtils.scala:     *  [Martin to Eugene: why needed?]
./src/library/scala/reflect/base/BuildUtils.scala:    // [Eugene++ to Martin] these are necessary for reification
./src/library/scala/reflect/base/MirrorOf.scala:// [Eugene++ to Martin] why was this a member of `scala.reflect`, but not `scala.reflect.base`?
./src/library/scala/reflect/base/Positions.scala:  // [Eugene++] why do we have this in base?
./src/library/scala/reflect/base/StandardDefinitions.scala:// [Eugene++] not sure whether we need this in the top level of the universe
./src/library/scala/reflect/base/StandardDefinitions.scala:  // [Eugene] todo. shortcut to these fields if possible when generating tags
./src/library/scala/reflect/base/StandardDefinitions.scala:    def ListClass   : ClassSymbol // [Eugene] I'd say List has earned its right to be here
./src/library/scala/reflect/base/Symbols.scala:  // [Eugene++ to Martin] why is Symbol >: Null, whereas all other symbol types are not nullable?
./src/library/scala/reflect/base/Symbols.scala:    // [Eugene++ to Martin] do we leave this here?
./src/library/scala/reflect/base/Symbols.scala:    // [Eugene++] when this becomes `moduleClass: ClassSymbol`, it will be the happiest day in my life
./src/library/scala/reflect/base/TagInterop.scala:  // [Eugene++] `mirror` parameters are now of type `Any`, because I can't make these path-dependent types work
./src/library/scala/reflect/base/TagInterop.scala:  // [Eugene++] would be great if we could approximate the interop without any mirrors
./src/library/scala/reflect/base/Trees.scala:// [Eugene++] of all reflection APIs, this one is in the biggest need of review and documentation
./src/library/scala/reflect/base/Trees.scala:// [Eugene++] now when trees are finally abstract types, can we do something for this?
./src/library/scala/reflect/base/Trees.scala:  // [Eugene++] todo. discuss nullability of abstract types
./src/library/scala/reflect/base/Trees.scala:   *  Selectors are a list of pairs of names (from, to). // [Eugene++] obviously, they no longer are. please, document!
./src/library/scala/reflect/base/Trees.scala:   *  If the block is empty, the `expr` is set to `Literal(Constant(()))`. // [Eugene++] check this
./src/library/scala/reflect/base/Trees.scala:   *  If the guard is not present, the `guard` is set to `EmptyTree`. // [Eugene++] check this
./src/library/scala/reflect/base/Trees.scala:   *  If the body is not specified, the `body` is set to `EmptyTree`. // [Eugene++] check this
./src/library/scala/reflect/base/Trees.scala:   *  If the alternative is not present, the `elsep` is set to `EmptyTree`. // [Eugene++] check this
./src/library/scala/reflect/base/Trees.scala:   *  // [Eugene++] say something about `val (foo, bar) = baz` and likes.
./src/library/scala/reflect/base/Trees.scala:  /** [Eugene++] comment me! */
./src/library/scala/reflect/base/Trees.scala:   *  If the finalizer is not present, the `finalizer` is set to `EmptyTree`. // [Eugene++] check this
./src/library/scala/reflect/base/Trees.scala:   *  [Eugene++] what is it used for?
./src/library/scala/reflect/base/Trees.scala:  // [Eugene++] don't see why we need it, when we have Select
./src/library/scala/reflect/base/Trees.scala:  // [Eugene++] temporarily moved here until SI-5863 is fixed
./src/library/scala/reflect/base/Types.scala:  implicit val TypeTagg: ClassTag[Type] // [Eugene++] rename!
./src/library/scala/reflect/base/TypeTags.scala: * [Eugene++] also mention sensitivity to prefixes, i.e. that rb.TypeTag is different from ru.TypeTag
./src/library/scala/reflect/base/TypeTags.scala: * [Eugene++] migratability between mirrors and universes is also worth mentioning
./src/library/scala/reflect/base/TypeTags.scala: *    // [Eugene++] it might be useful, though, to guard against abstractness of the incoming type.
./src/library/scala/reflect/base/TypeTags.scala:// [Eugene++] implement serialization for typetags
./src/library/scala/reflect/makro/internal/package.scala:// [Eugene++] how do I hide this from scaladoc?
./src/library/scala/reflect/ScalaLongSignature.java: * [Martin to Eugene++] Todo: Move to somewhere else?
./src/library/scala/reflect/ScalaSignature.java:/**   * [Martin to Eugene++] Todo: Move to somewhere else?
./src/library/scala/util/Marshal.scala:      // [Eugene] needs review
./src/partest/scala/tools/partest/nest/Diff.java:   "An O(ND) Difference Algorithm and its Variations", Eugene Myers,
./src/reflect/scala/reflect/api/Exprs.scala:      // [Eugene++] this is important
./src/reflect/scala/reflect/api/FlagSets.scala:  // [Eugene++] any other flags we would like to expose?
./src/reflect/scala/reflect/api/FrontEnds.scala:// [Martin to Eugene] Todo: Needs to be evicted from API
./src/reflect/scala/reflect/api/FrontEnds.scala:// [Eugene++ to Martin] but how? we need them for macros
./src/reflect/scala/reflect/api/Importers.scala:// [Eugene++] this is important
./src/reflect/scala/reflect/api/Mirrors.scala:  // [Eugene] also, it might make sense to provide shortcuts for the API
./src/reflect/scala/reflect/api/Mirrors.scala:  // [Eugene] another improvement would be have mirrors reproduce the structure of the reflection domain
./src/reflect/scala/reflect/api/Positions.scala:  // [Eugene++] can this method be of use for macros?
./src/reflect/scala/reflect/api/Symbols.scala:    // [Eugene++] we cannot expose the `annotations` method because it doesn't auto-initialize a symbol (see SI-5423)
./src/reflect/scala/reflect/api/Symbols.scala:     *  [Eugene++] I need a review of the implementation
./src/reflect/scala/reflect/api/Symbols.scala:     *  [Eugene++] because it's useful for macros
./src/reflect/scala/reflect/api/TagInterop.scala:  // [Eugene++] would be great if we could approximate the interop without any mirrors
./src/reflect/scala/reflect/api/TagInterop.scala:    // [Eugene++] implement more sophisticated logic
./src/reflect/scala/reflect/api/Types.scala:     *  [Eugene++] why not List?
./src/reflect/scala/reflect/api/Types.scala:     *  [Eugene++] the order needs to be reversed back, at least in the public API
./src/reflect/scala/reflect/api/Types.scala:  // [Eugene to Paul] needs review!
./src/reflect/scala/reflect/internal/Definitions.scala:  // [Eugene] find a way to make these non-lazy
./src/reflect/scala/reflect/internal/Definitions.scala:    // [Eugene++] ScalaPackage and JavaLangPackage are never ever shared between mirrors
./src/reflect/scala/reflect/internal/Definitions.scala:      def SeqFactory = getMember(ScalaRunTimeModule, nme.Seq) // [Eugene++] obsolete?
./src/reflect/scala/reflect/internal/Definitions.scala:      // [Eugene++] `getMemberClass` leads to crashes in mixin:
./src/reflect/scala/reflect/internal/Definitions.scala:      // [Eugene++] should be a ClassCastException instead?
./src/reflect/scala/reflect/internal/Definitions.scala:      // [Eugene++] should be a ClassCastException instead?
./src/reflect/scala/reflect/internal/Definitions.scala:      // [Eugene++] should be a ClassCastException instead?
./src/reflect/scala/reflect/internal/Definitions.scala:      // [Eugene++] should be a ClassCastException instead?
./src/reflect/scala/reflect/internal/Definitions.scala:      // [Eugene++] is this a bug?
./src/reflect/scala/reflect/internal/Definitions.scala:      // [Eugene++] should be a ClassCastException instead?
./src/reflect/scala/reflect/internal/Importers.scala:  // [Eugene] possible to make this less cast-heavy?
./src/reflect/scala/reflect/internal/Printers.scala:// [Eugene++ to Martin] we need to unify this prettyprinter with NodePrinters
./src/reflect/scala/reflect/internal/Printers.scala:        // [Eugene++] todo. this is not 100% correct, but is necessary for sane printing
./src/reflect/scala/reflect/internal/StdNames.scala:  // [Eugene++ to Martin] had to move a lot of stuff from here to TermNames to satisfy the contract
./src/reflect/scala/reflect/internal/Symbols.scala:    // [Eugene] todo. needs to be reviewed and [only then] rewritten without explicit returns
./src/reflect/scala/reflect/internal/Trees.scala:      // [Eugene++] no longer compiles after I moved the `Apply` case class here
./src/reflect/scala/reflect/internal/Types.scala:      case ConstantType(value) => widen.erasure // [Eugene to Martin] constant types are unaffected by erasure. weird.
./src/reflect/scala/reflect/internal/Types.scala:        // [Eugene] erasure screws up all ThisTypes for modules into PackageTypeRefs
./src/reflect/scala/reflect/internal/Types.scala:    // [Eugene] to be discussed and refactored
./src/reflect/scala/reflect/internal/Types.scala:    // [Eugene] is this comprehensive?
./src/reflect/scala/reflect/internal/Types.scala:        // [Eugene to Paul] needs review
./src/reflect/scala/reflect/makro/Infrastructure.scala:   *  // [Eugene++] using this guy will tremendously slow down the compilation
./src/reflect/scala/reflect/makro/Settings.scala:  // [Eugene] ugly? yes, but I don't really fancy copy/pasting all our settings here and keep it synchronized at all times
./src/reflect/scala/reflect/makro/TreeBuilder.scala:// [Eugene] I added some stuff that was necessary for typetag materialization macros
./src/reflect/scala/reflect/runtime/JavaMirrors.scala:    // [Eugene++ to Martin] not weak? why?
./src/reflect/scala/reflect/runtime/JavaMirrors.scala:      // [Eugene++] `jclazz.isLocalClass` doesn't work because of problems with `getSimpleName`
./src/reflect/scala/reflect/runtime/JavaMirrors.scala:  // [Eugene++] overflow from Paul's changes made concurrently with reflection refactoring
./src/reflect/scala/reflect/runtime/JavaMirrors.scala:      // [Eugene++] this makes toolbox tests pass, but it's a mere workaround for SI-5865
./src/reflect/scala/reflect/runtime/package.scala:  // [Eugene++ to Martin] removed `mirrorOfLoader`, because one can use `universe.runtimeMirror` instead
./src/reflect/scala/reflect/runtime/SymbolLoaders.scala:    // [Eugene++] am I doing this right?
./src/reflect/scala/reflect/runtime/SymbolLoaders.scala:    // [Eugene++ to Martin] test/files/run/t5256g and test/files/run/t5256h will crash
./src/reflect/scala/reflect/runtime/SynchronizedSymbols.scala:    // [Eugene++ to Martin] doesn't override anything. no longer necessary?
./src/reflect/scala/tools/nsc/io/Path.scala:  // [Eugene++] I hope that noone relied on this method
./test/scaladoc/resources/implicits-base-res.scala:// [Eugene to Vlad] how do I test typetags here?