From bdc8c11581b0fc67cf895ba349e43b2081e29c59 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Tue, 28 Apr 2009 13:33:47 +0000 Subject: removed Namers.scala.1 / .2 --- .../scala/tools/nsc/typechecker/Namers.scala.1 | 1047 -------------------- .../scala/tools/nsc/typechecker/Namers.scala.2 | 1046 ------------------- 2 files changed, 2093 deletions(-) delete mode 100755 src/compiler/scala/tools/nsc/typechecker/Namers.scala.1 delete mode 100755 src/compiler/scala/tools/nsc/typechecker/Namers.scala.2 (limited to 'src') diff --git a/src/compiler/scala/tools/nsc/typechecker/Namers.scala.1 b/src/compiler/scala/tools/nsc/typechecker/Namers.scala.1 deleted file mode 100755 index 910418ba65..0000000000 --- a/src/compiler/scala/tools/nsc/typechecker/Namers.scala.1 +++ /dev/null @@ -1,1047 +0,0 @@ -/* NSC -- new Scala compiler - * Copyright 2005-2009 LAMP/EPFL - * @author Martin Odersky - */ -// $Id: Namers.scala 17117 2009-02-16 14:56:54Z odersky $ - -package scala.tools.nsc.typechecker - -import scala.collection.mutable.HashMap -import scala.tools.nsc.util.Position -import symtab.Flags -import symtab.Flags._ - -/** This trait declares methods to create symbols and to enter them into scopes. - * - * @author Martin Odersky - * @version 1.0 - */ -trait Namers { self: Analyzer => - import global._ - import definitions._ - import posAssigner.atPos - - /** Convert to corresponding type parameters all skolems of method parameters - * which appear in `tparams`. - */ - class DeSkolemizeMap(tparams: List[Symbol]) extends TypeMap { - def apply(tp: Type): Type = tp match { - case TypeRef(pre, sym, args) - if (sym.isTypeSkolem && (tparams contains sym.deSkolemize)) => -// println("DESKOLEMIZING "+sym+" in "+sym.owner) - mapOver(rawTypeRef(NoPrefix, sym.deSkolemize, args)) -/* - case PolyType(tparams1, restpe) => - new DeSkolemizeMap(tparams1 ::: tparams).mapOver(tp) - case ClassInfoType(parents, decls, clazz) => - val parents1 = List.mapConserve(parents)(this) - if (parents1 eq parents) tp else ClassInfoType(parents1, decls, clazz) -*/ - case _ => - mapOver(tp) - } - } - - private class NormalNamer(context : Context) extends Namer(context) - def newNamer(context : Context) : Namer = new NormalNamer(context) - - private[typechecker] val caseClassOfModuleClass = new HashMap[Symbol, ClassDef] - - def resetNamer() { - caseClassOfModuleClass.clear - } - - abstract class Namer(val context: Context) { - - val typer = newTyper(context) - - def setPrivateWithin[Sym <: Symbol](tree: Tree, sym: Sym, mods: Modifiers): Sym = { - if (!mods.privateWithin.isEmpty) - sym.privateWithin = typer.qualifyingClassContext(tree, mods.privateWithin, true).owner - sym - } - - def inConstructorFlag: Long = - if (context.owner.isConstructor && !context.inConstructorSuffix || context.owner.isEarly) INCONSTRUCTOR - else 0l - - def moduleClassFlags(moduleFlags: Long) = - (moduleFlags & ModuleToClassFlags) | FINAL | inConstructorFlag - - def updatePosFlags(sym: Symbol, pos: Position, flags: Long): Symbol = { - if (settings.debug.value) log("overwriting " + sym) - val lockedFlag = sym.flags & LOCKED - sym.reset(NoType) - sym setPos pos - sym.flags = flags | lockedFlag - if (sym.isModule && sym.moduleClass != NoSymbol) - updatePosFlags(sym.moduleClass, pos, moduleClassFlags(flags)) - if (sym.owner.isPackageClass && - (sym.linkedSym.rawInfo.isInstanceOf[loaders.SymbolLoader] || - sym.linkedSym.rawInfo.isComplete && runId(sym.validTo) != currentRunId)) - // pre-set linked symbol to NoType, in case it is not loaded together with this symbol. - sym.linkedSym.setInfo(NoType) - sym - } - - private def isTemplateContext(context: Context): Boolean = context.tree match { - case Template(_, _, _) => true - case Import(_, _) => isTemplateContext(context.outer) - case _ => false - } - - private var innerNamerCache: Namer = null - protected def makeConstructorScope(classContext : Context) : Context = { - val outerContext = classContext.outer.outer - outerContext.makeNewScope(outerContext.tree, outerContext.owner)(Constructor1ScopeKind) - } - - def namerOf(sym: Symbol): Namer = { - - def innerNamer: Namer = { - if (innerNamerCache eq null) - innerNamerCache = - if (!isTemplateContext(context)) this - else newNamer(context.make(context.tree, context.owner, scopeFor(context.tree, InnerScopeKind))) - innerNamerCache - } - - def primaryConstructorParamNamer: Namer = { //todo: can we merge this with SCCmode? - val classContext = context.enclClass - val paramContext = makeConstructorScope(classContext) - val unsafeTypeParams = context.owner.unsafeTypeParams - unsafeTypeParams foreach(sym => paramContext.scope.enter(sym)) - newNamer(paramContext) - } - if (sym.isTerm) { - if (sym.hasFlag(PARAM) && sym.owner.isPrimaryConstructor) - primaryConstructorParamNamer - else if (sym.hasFlag(PARAMACCESSOR) && !inIDE) - primaryConstructorParamNamer - else innerNamer - } else innerNamer - } - - protected def conflict(newS : Symbol, oldS : Symbol) : Boolean = { - (!oldS.isSourceMethod || - nme.isSetterName(newS.name) || - newS.owner.isPackageClass) && - !((newS.owner.isTypeParameter || newS.owner.isAbstractType) && - newS.name.length==1 && newS.name(0)=='_') //@M: allow repeated use of `_' for higher-order type params - } - - // IDE hook - protected def setInfo[Sym <: Symbol](sym : Sym)(tpe : LazyType) : Sym = sym.setInfo(tpe) - - private def doubleDefError(pos: Position, sym: Symbol) { - context.error(pos, - sym.name.toString() + " is already defined as " + - (if (sym.hasFlag(SYNTHETIC)) - "(compiler-generated) "+ (if (sym.isModule) "case class companion " else "") - else "") + - (if (sym.hasFlag(CASE)) "case class " + sym.name else sym.toString())) - } - - private def inCurrentScope(m: Symbol): Boolean = { - if (context.owner.isClass) context.owner == m.owner - else m.owner.isClass && context.scope == m.owner.info.decls - } - - def enterInScope(sym: Symbol): Symbol = enterInScope(sym, context.scope) - - def enterInScope(sym: Symbol, scope: Scope): Symbol = { - // allow for overloaded methods - if (!(sym.isSourceMethod && sym.owner.isClass && !sym.owner.isPackageClass)) { - var prev = scope.lookupEntryWithContext(sym.name)(context.owner); - if ((prev ne null) && inIDE) { - var guess = prev - while ((guess ne null) && (guess.sym ne sym)) guess = scope.lookupNextEntry(guess) - if (guess != null) prev = guess - while (prev != null && (!prev.sym.hasRawInfo || !prev.sym.rawInfo.isComplete || - (prev.sym.sourceFile == null && sym.getClass == prev.sym.getClass))) { - if (!prev.sym.hasRawInfo || prev.sym.rawInfo.isComplete) { - Console.println("DITCHING: " + prev.sym) - } - scope unlink prev.sym - prev = scope.lookupNextEntry(prev) - } - val sym0 = scope enter sym - if (sym0 ne sym) { - Console.println("WEIRD: " + sym0 + " vs. " + sym + " " + sym0.id + " " + sym.id + " " + sym.sourceFile + " " + sym0.sourceFile) - } - if (prev != null && (sym0 ne prev.sym) && conflict(sym0,prev.sym)) { - doubleDefError(sym0.pos, prev.sym) - } - sym0 - } else if ((prev ne null) && prev.owner == scope && conflict(sym, prev.sym)) { - doubleDefError(sym.pos, prev.sym) - sym setInfo ErrorType // don't do this in IDE for stability - scope unlink prev.sym // let them co-exist... - scope enter sym - } else scope enter sym - } else scope enter sym - } - - def enterPackageSymbol(pos: Position, name: Name): Symbol = { - val (cscope, cowner) = - if (context.owner == EmptyPackageClass) (RootClass.info.decls, RootClass) - else (context.scope, context.owner) - val p: Symbol = cscope.lookupWithContext(name)(context.owner) - if (p.isPackage && cscope == p.owner.info.decls) { - p - } else { - val pkg = cowner.newPackage(pos, name) - // IDE: newScope should be ok because packages are never destroyed. - if (inIDE) assert(!pkg.moduleClass.hasRawInfo || !pkg.moduleClass.rawInfo.isComplete) - pkg.moduleClass.setInfo(new PackageClassInfoType(newScope, pkg.moduleClass, null)) - pkg.setInfo(pkg.moduleClass.tpe) - enterInScope(pkg, cscope) - } - } - - def enterClassSymbol(tree : ClassDef): Symbol = { - var c: Symbol = context.scope.lookupWithContext(tree.name)(context.owner); - if (!inIDE && c.isType && c.owner.isPackageClass && context.scope == c.owner.info.decls && !currentRun.compiles(c)) { - updatePosFlags(c, tree.pos, tree.mods.flags) - setPrivateWithin(tree, c, tree.mods) - } else { - var sym = context.owner.newClass(tree.pos, tree.name) - sym = sym.setFlag(tree.mods.flags | inConstructorFlag) - sym = setPrivateWithin(tree, sym, tree.mods) - c = enterInScope(sym) - } - if (c.owner.isPackageClass) { - val file = context.unit.source.file - val clazz = c.asInstanceOf[ClassSymbol] - if (settings.debug.value && (clazz.sourceFile ne null) && !clazz.sourceFile.equals(file)) { - Console.err.println("SOURCE MISMATCH: " + clazz.sourceFile + " vs. " + file + " SYM=" + c); - } - clazz.sourceFile = file - if (clazz.sourceFile ne null) { - assert(inIDE || !currentRun.compiles(clazz) || clazz.sourceFile == currentRun.symSource(c)); - currentRun.symSource(c) = clazz.sourceFile - } - } - assert(c.name.toString.indexOf('(') == -1) - c - } - - /** Enter a module symbol. The tree parameter can be either a module definition - * or a class definition */ - def enterModuleSymbol(tree : ModuleDef): Symbol = { - // .pos, mods.flags | MODULE | FINAL, name - var m: Symbol = context.scope.lookupWithContext(tree.name)(context.owner) - val moduleFlags = tree.mods.flags | MODULE | FINAL - if (m.isModule && !m.isPackage && inCurrentScope(m) && - ((!inIDE && !currentRun.compiles(m)) || (m hasFlag SYNTHETIC))) { - updatePosFlags(m, tree.pos, moduleFlags) - setPrivateWithin(tree, m, tree.mods) - context.unit.synthetics -= m - } else { - m = context.owner.newModule(tree.pos, tree.name) - m.setFlag(moduleFlags) - m = setPrivateWithin(tree, m, tree.mods) - m = enterInScope(m) - - m.moduleClass.setFlag(moduleClassFlags(moduleFlags)) - setPrivateWithin(tree, m.moduleClass, tree.mods) - } - if (m.owner.isPackageClass) { - m.moduleClass.sourceFile = context.unit.source.file - currentRun.symSource(m) = m.moduleClass.sourceFile - } - m - } - - def enterSyms(trees: List[Tree]): Namer = { - var namer : Namer = this - for (tree <- trees) { - val txt = namer.enterSym(tree) - if (!(txt eq namer.context)) namer = newNamer(txt) - } - namer - } - - def newTypeSkolems(tparams: List[Symbol]): List[Symbol] = { - val tskolems = tparams map (_.newTypeSkolem) - val ltp = new LazyType { - override def complete(sym: Symbol) { - sym setInfo sym.deSkolemize.info.substSym(tparams, tskolems) //@M the info of a skolem is the skolemized info of the actual type parameter of the skolem - } - } - tskolems foreach (_.setInfo(ltp)) - tskolems - } - - /** Replace type parameters with their TypeSkolems, which can later be deskolemized to the original type param - * (a skolem is a representation of a bound variable when viewed inside its scope) - */ - def skolemize(tparams: List[TypeDef]) { - val tskolems = newTypeSkolems(tparams map (_.symbol)) - for ((tparam, tskolem) <- tparams zip tskolems) tparam.symbol = tskolem - } - - def applicableTypeParams(owner: Symbol): List[Symbol] = - if (inIDE && (owner eq NoSymbol)) List() - else if (owner.isTerm || owner.isPackageClass) List() - else applicableTypeParams(owner.owner) ::: owner.typeParams - - def enterSym(tree: Tree): Context = try { - - def finishWith(tparams: List[TypeDef]) { - val sym = tree.symbol - if (settings.debug.value) log("entered " + sym + " in " + context.owner + ", scope-id = " + context.scope.hashCode()); - var ltype = namerOf(sym).typeCompleter(tree) - if (!tparams.isEmpty) { - //@M! TypeDef's type params are handled differently - //@M e.g., in [A[x <: B], B], A and B are entered first as both are in scope in the definition of x - //@M x is only in scope in `A[x <: B]' - if(!sym.isAbstractType) //@M TODO: change to isTypeMember ? - newNamer(context.makeNewScope(tree, sym)(FinishWithScopeKind)).enterSyms(tparams) - ltype = new PolyTypeCompleter(tparams, ltype, tree, sym, context) //@M - if (sym.isTerm) skolemize(tparams) - } - setInfo(sym)(ltype) - } - def finish = finishWith(List()) - - if (tree.symbol == NoSymbol) { - val owner = context.owner - tree match { - case PackageDef(name, stats) => - tree.symbol = enterPackageSymbol(tree.pos, name) - val namer = newNamer( - context.make(tree, tree.symbol.moduleClass, tree.symbol.info.decls)) - namer.enterSyms(stats) - case tree @ ClassDef(mods, name, tparams, impl) => - tree.symbol = enterClassSymbol(tree) - finishWith(tparams) - if ((mods.flags & CASE) != 0) { - var m: Symbol = context.scope.lookupWithContext(tree.name.toTermName)(context.owner).filter(! _.isSourceMethod) - if (!(m.isModule && inCurrentScope(m) && (inIDE || currentRun.compiles(m)))) { - m = enterSyntheticSym(caseModuleDef(tree)) - } - caseClassOfModuleClass(m.moduleClass) = tree - } - case tree @ ModuleDef(mods, name, _) => - tree.symbol = enterModuleSymbol(tree) - tree.symbol.moduleClass.setInfo(namerOf(tree.symbol).moduleClassTypeCompleter((tree))) - finish - - case ValDef(mods, name, tp, rhs) => - if ((!context.owner.isClass || - (mods.flags & (PRIVATE | LOCAL)) == (PRIVATE | LOCAL) || - name.endsWith(nme.OUTER, nme.OUTER.length) || - context.unit.isJava) && - (mods.flags & LAZY) == 0) { - tree.symbol = enterInScope(owner.newValue(tree.pos, name) - .setFlag(mods.flags)) - finish - } else { - // add getter and possibly also setter - val accflags: Long = ACCESSOR | - (if ((mods.flags & MUTABLE) != 0) mods.flags & ~MUTABLE & ~PRESUPER - else mods.flags & ~PRESUPER | STABLE) - if (nme.isSetterName(name)) - context.error(tree.pos, "Names of vals or vars may not end in `_='") - var getter = owner.newMethod(tree.pos, name).setFlag(accflags) - setPrivateWithin(tree, getter, mods) - getter = enterInScope(getter).asInstanceOf[TermSymbol] - setInfo(getter)(namerOf(getter).getterTypeCompleter(tree)) - if ((mods.flags & MUTABLE) != 0) { - var setter = owner.newMethod(tree.pos, nme.getterToSetter(name)) - .setFlag(accflags & ~STABLE & ~CASEACCESSOR) - setPrivateWithin(tree, setter, mods) - setter = enterInScope(setter).asInstanceOf[TermSymbol] - setInfo(setter)(namerOf(setter).setterTypeCompleter(tree)) - } - tree.symbol = - if ((mods.flags & DEFERRED) == 0) { - var vsym = - if (!context.owner.isClass) { - assert((mods.flags & LAZY) != 0) // if not a field, it has to be a lazy val - owner.newValue(tree.pos, name + "$lzy" ).setFlag(mods.flags | MUTABLE) - } else { - owner.newValue(tree.pos, nme.getterToLocal(name)) - .setFlag(mods.flags & FieldFlags | PRIVATE | LOCAL | (if ((mods.flags & LAZY) != 0) MUTABLE else 0)) - } - vsym = enterInScope(vsym).asInstanceOf[TermSymbol] - setInfo(vsym)(namerOf(vsym).typeCompleter(tree)) - if ((mods.flags & LAZY) != 0) - vsym.setLazyAccessor(getter) - vsym - } else getter - } - case DefDef(mods, nme.CONSTRUCTOR, tparams, _, _, _) => - var sym = owner.newConstructor(tree.pos).setFlag(mods.flags | owner.getFlag(ConstrFlags)) - setPrivateWithin(tree, sym, mods) - tree.symbol = enterInScope(sym) - finishWith(tparams) - case DefDef(mods, name, tparams, _, _, _) => - var sym = (owner.newMethod(tree.pos, name)).setFlag(mods.flags) - setPrivateWithin(tree, sym, mods) - tree.symbol = enterInScope(sym) - finishWith(tparams) - case TypeDef(mods, name, tparams, _) => - var flags: Long = mods.flags - if ((flags & PARAM) != 0) flags |= DEFERRED - var sym = new TypeSymbol(owner, tree.pos, name).setFlag(flags) - setPrivateWithin(tree, sym, mods) - tree.symbol = enterInScope(sym) - finishWith(tparams) - case DocDef(_, defn) => - enterSym(defn) - case imp @ Import(_, _) => - tree.symbol = NoSymbol.newImport(tree.pos) - setInfo(tree.symbol)(namerOf(tree.symbol).typeCompleter(tree)) - return (context.makeNewImport(imp)) - case _ => - } - } - this.context - } catch { - case ex: TypeError => - //Console.println("caught " + ex + " in enterSym")//DEBUG - typer.reportTypeError(tree.pos, ex) - this.context - } - - def enterSyntheticSym(tree: Tree): Symbol = { - enterSym(tree) - context.unit.synthetics(tree.symbol) = tree - tree.symbol - } - -// --- Lazy Type Assignment -------------------------------------------------- - - def typeCompleter(tree: Tree) = mkTypeCompleter(tree) { sym => - if (settings.debug.value) log("defining " + sym + Flags.flagsToString(sym.flags)+sym.locationString) - val tp = typeSig(tree) - tp match { - case TypeBounds(lo, hi) => - // check that lower bound is not an F-bound - for (val t <- lo) { - t match { - case TypeRef(_, sym, _) => sym.initialize - case _ => - } - } - case _ => - } - sym.setInfo(tp) - if ((sym.isAliasType || sym.isAbstractType) && !(sym hasFlag PARAM) && - !typer.checkNonCyclic(tree.pos, tp)) - sym.setInfo(ErrorType) // this early test is there to avoid infinite baseTypes when - // adding setters and getters --> bug798 - if (settings.debug.value) log("defined " + sym); - validate(sym) - } - - def moduleClassTypeCompleter(tree: Tree) = { - mkTypeCompleter(tree) { sym => - val moduleSymbol = tree.symbol - assert(moduleSymbol.moduleClass == sym) - if (inIDE && moduleSymbol.rawInfo.isComplete) { - // reset! - } - moduleSymbol.info // sets moduleClass info as a side effect. - //assert(sym.rawInfo.isComplete) - } - } - - def getterTypeCompleter(tree: Tree) = mkTypeCompleter(tree) { sym => - if (settings.debug.value) log("defining " + sym) - sym.setInfo(PolyType(List(), typeSig(tree))) - if (settings.debug.value) log("defined " + sym) - validate(sym) - } - - def setterTypeCompleter(tree: Tree) = mkTypeCompleter(tree) { sym => - if (settings.debug.value) log("defining " + sym); - sym.setInfo(MethodType(List(typeSig(tree)), UnitClass.tpe)) - if (settings.debug.value) log("defined " + sym); - validate(sym) - } - - def selfTypeCompleter(tree: Tree) = mkTypeCompleter(tree) { sym => - var selftpe = typer.typedType(tree).tpe - if (!(selftpe.typeSymbol isNonBottomSubClass sym.owner)) - selftpe = intersectionType(List(sym.owner.tpe, selftpe)) -// println("completing self of "+sym.owner+": "+selftpe) - sym.setInfo(selftpe) - } - - private def widenIfNotFinal(sym: Symbol, tpe: Type, pt: Type): Type = { - val getter = - if (sym.isValue && sym.owner.isClass && (sym hasFlag PRIVATE)) - sym.getter(sym.owner) - else sym - def isHidden(tp: Type): Boolean = tp match { - case SingleType(pre, sym) => - (sym isLessAccessibleThan getter) || isHidden(pre) - case ThisType(sym) => - sym isLessAccessibleThan getter - case p: SimpleTypeProxy => - isHidden(p.underlying) - case _ => - false - } - val tpe1 = tpe.deconst - val tpe2 = tpe1.widen - if ((sym.isVariable || sym.isMethod && !(sym hasFlag ACCESSOR))) - if (tpe2 <:< pt) tpe2 else tpe1 - else if (isHidden(tpe)) tpe2 - else if (!(sym hasFlag FINAL)) tpe1 - else tpe - } - - def enterValueParams(owner: Symbol, vparamss: List[List[ValDef]]): List[List[Symbol]] = { - def enterValueParam(param: ValDef): Symbol = { - if (inIDE) param.symbol = { - var sym = owner.newValueParameter(param.pos, param.name). - setFlag(param.mods.flags & (BYNAMEPARAM | IMPLICIT)) - setPrivateWithin(param, sym, param.mods) - sym = enterInScope(sym).asInstanceOf[TermSymbol] - if (!sym.hasRawInfo || sym.rawInfo.isComplete) - setInfo(sym)(typeCompleter(param)) - sym - } else param.symbol = setInfo( - enterInScope{ - val sym = owner.newValueParameter(param.pos, param.name). - setFlag(param.mods.flags & (BYNAMEPARAM | IMPLICIT)) - setPrivateWithin(param, sym, param.mods) - })(typeCompleter(param)) - param.symbol - } - vparamss.map(_.map(enterValueParam)) - } - - private def templateSig(templ: Template): Type = { - val clazz = context.owner - def checkParent(tpt: Tree): Type = { - val tp = tpt.tpe - if (tp.typeSymbol == context.owner) { - context.error(tpt.pos, ""+tp.typeSymbol+" inherits itself") - AnyRefClass.tpe - } else if (tp.isError) { - AnyRefClass.tpe - } else { - tp - } - } - def enterSelf(self: ValDef) { - if (!self.tpt.isEmpty) { - clazz.typeOfThis = selfTypeCompleter(self.tpt) - self.symbol = clazz.thisSym.setPos(self.pos) - } else { - self.tpt.tpe = NoType - if (self.name != nme.WILDCARD) { - clazz.typeOfThis = clazz.tpe - self.symbol = clazz.thisSym - } else if (self ne emptyValDef) { - self.symbol = clazz.newThisSym(self.pos) setInfo clazz.tpe - } - } - if (self.name != nme.WILDCARD) { - self.symbol.name = self.name - self.symbol = context.scope enter self.symbol - } - } - var templateNamer = newNamer(context.make(templ, clazz, decls)) - templateNamer = templateNamer.enterSyms(template.body filter treeInfo.isEarlyType) - var parents = typer.parentTypes(templ) map checkParent - enterSelf(templ.self) - val decls = newClassScope(clazz) - templateNamer = templateNamer.enterSyms(templ.body) - - /* add overridden virtuals to parents - val overridden = clazz.overriddenVirtuals - if (!overridden.isEmpty) - parents = parents ::: ( overridden map ( - sym => TypeRef(clazz.owner.thisType, sym, clazz.typeParams map (_.tpe)))) - println("Parents of "+clazz+":"+parents) - - // check that virtual classses are only defined as members of templates - if (clazz.isVirtualClass && !clazz.owner.isClass) - context.error( - clazz.pos, - "virtual traits and their subclasses must be defined as members of some other class") - - // make subclasses of virtual classes virtual as well; check that - // they are defined in same scope. - val virtualParents = parents map (_.typeSymbol) filter (_.isVirtualClass) - virtualParents find { - vp => !(clazz.owner.isClass && (clazz.owner isSubClass vp.owner)) - } match { - case Some(vp) => - context.error( - clazz.pos, - "subclass of virtual "+vp+ - " needs to be defined at same level,\nas member of "+vp.owner) - case None => - if (!virtualParents.isEmpty) clazz setFlag DEFERRED // make it virtual - } - */ - - // add apply and unapply methods to companion objects of case classes, - // unless they exist already - Namers.this.caseClassOfModuleClass get clazz match { - case Some(cdef) => - val go = if (inIDE) { // garbage collect in the presentaiton compiler. - assert(cdef.symbol != null && cdef.symbol != NoSymbol) - if (!cdef.symbol.isClass || !cdef.symbol.hasFlag(CASE) || cdef.symbol.rawInfo == NoType) false - else true - } else true - if (go) - addApplyUnapply(cdef, templateNamer) - if (!go || !inIDE) caseClassOfModuleClass -= clazz - if (!go) { - val rem = clazz.linkedModuleOfClass - assert(rem != NoSymbol) - } - case None => - } - ClassInfoType(parents, decls, clazz) - } - - private def classSig(tparams: List[TypeDef], impl: Template): Type = - polyType(typer.reenterTypeParams(tparams), templateSig(impl)) - - private def methodSig(tparams: List[TypeDef], vparamss: List[List[ValDef]], - tpt: Tree, rhs: Tree): Type = { - val meth = context.owner - - val tparamSyms = typer.reenterTypeParams(tparams) - var vparamSymss = - if (inIDE && meth.isPrimaryConstructor) { - // @S: because they have already been entered this way.... - - enterValueParams(meth.owner.owner, vparamss) - } else { - enterValueParams(meth, vparamss) - } - if (tpt.isEmpty && meth.name == nme.CONSTRUCTOR) { - tpt.tpe = context.enclClass.owner.tpe - tpt setPos meth.pos - } - - if (onlyPresentation && methodArgumentNames != null) - methodArgumentNames(meth) = vparamss.map(_.map(_.symbol)); - - def convertToDeBruijn(vparams: List[Symbol], level: Int): TypeMap = new TypeMap { - def debruijnFor(param: Symbol) = - DeBruijnIndex(level, vparams indexOf param) - def apply(tp: Type) = { - tp match { - case SingleType(_, sym) => - if (settings.Xexperimental.value && sym.owner == meth && (vparams contains sym)) { -/* - if (sym hasFlag IMPLICIT) { - context.error(sym.pos, "illegal type dependence on implicit parameter") - ErrorType - } else -*/ - debruijnFor(sym) - } else tp - case MethodType(formals, restpe) => - val formals1 = List.mapConserve(formals)(this) - val restpe1 = convertToDeBruijn(vparams, level + 1)(restpe) - if ((formals1 eq formals) && (restpe1 eq restpe)) tp - else copyMethodType(tp, formals1, restpe1) - case _ => - mapOver(tp) - } - } - - object treeTrans extends TypeMapTransformer { - override def transform(tree: Tree): Tree = - tree match { - case Ident(name) if (vparams contains tree.symbol) => - val dtpe = debruijnFor(tree.symbol) - val dsym = - newLocalDummy(context.owner, tree.symbol.pos) - .newValue(tree.symbol.pos, name) - - dsym.setFlag(PARAM) - dsym.setInfo(dtpe) - Ident(name).setSymbol(dsym).copyAttrs(tree).setType(dtpe) - case tree => super.transform(tree) - } - } - - override def mapOver(arg: Tree) = Some(treeTrans.transform(arg)) - } - - val checkDependencies: TypeTraverser = new TypeTraverser { - def traverse(tp: Type) = { - tp match { - case SingleType(_, sym) => - if (sym.owner == meth && (vparamSymss exists (_ contains sym))) - context.error( - sym.pos, - "illegal dependent method type"+ - (if (settings.Xexperimental.value) - ": parameter appears in the type of another parameter in the same section or an earlier one" - else "")) - case _ => - mapOver(tp) - } - this - } - } - - def makeMethodType(vparams: List[Symbol], restpe: Type) = { - val formals = vparams map (vparam => - if (meth hasFlag JAVA) objToAny(vparam.tpe) else vparam.tpe) - val restpe1 = convertToDeBruijn(vparams, 1)(restpe) - if (!vparams.isEmpty && vparams.head.hasFlag(IMPLICIT)) - ImplicitMethodType(formals, restpe1) - else if (meth hasFlag JAVA) JavaMethodType(formals, restpe1) - else MethodType(formals, restpe1) - } - - def thisMethodType(restpe: Type) = - polyType( - tparamSyms, - if (vparamSymss.isEmpty) PolyType(List(), restpe) - else checkDependencies((vparamSymss :\ restpe) (makeMethodType))) - - var resultPt = if (tpt.isEmpty) WildcardType else typer.typedType(tpt).tpe - val site = meth.owner.thisType - - def overriddenSymbol = intersectionType(meth.owner.info.parents).member(meth.name).filter(sym => - sym != NoSymbol && (site.memberType(sym) matches thisMethodType(resultPt))) - - // fill in result type and parameter types from overridden symbol if there is a unique one. - if (meth.owner.isClass && (tpt.isEmpty || vparamss.exists(_.exists(_.tpt.isEmpty)))) { - // try to complete from matching definition in base type - for (vparams <- vparamss; vparam <- vparams) - if (vparam.tpt.isEmpty) vparam.symbol setInfo WildcardType - val overridden = overriddenSymbol - if (overridden != NoSymbol && !(overridden hasFlag OVERLOADED)) { - resultPt = site.memberType(overridden) match { - case PolyType(tparams, rt) => rt.substSym(tparams, tparamSyms) - case mt => mt - } - - for (vparams <- vparamss) { - var pfs = resultPt.paramTypes - for (vparam <- vparams) { - if (vparam.tpt.isEmpty) { - vparam.tpt.tpe = pfs.head - vparam.tpt setPos vparam.pos - vparam.symbol setInfo pfs.head - } - pfs = pfs.tail - } - resultPt = resultPt.resultType - } - resultPt match { - case PolyType(List(), rtpe) => resultPt = rtpe - case MethodType(List(), rtpe) => resultPt = rtpe - case _ => - } - if (tpt.isEmpty) { - // provisionally assign `meth' a method type with inherited result type - // that way, we can leave out the result type even if method is recursive. - meth setInfo thisMethodType(resultPt) - } - } - } - // Add a () parameter section if this overrides dome method with () parameters. - if (meth.owner.isClass && vparamss.isEmpty && overriddenSymbol.alternatives.exists( - _.info.isInstanceOf[MethodType])) { - vparamSymss = List(List()) - } - for (vparams <- vparamss; vparam <- vparams if vparam.tpt.isEmpty) { - context.error(vparam.pos, "missing parameter type") - vparam.tpt.tpe = ErrorType - } - - thisMethodType( - if (tpt.isEmpty) { - val pt = resultPt.substSym(tparamSyms, tparams map (_.symbol)) - tpt.tpe = widenIfNotFinal(meth, typer.computeType(rhs, pt), pt) - tpt setPos meth.pos - tpt.tpe - } else typer.typedType(tpt).tpe) - } - - //@M! an abstract type definition (abstract type member/type parameter) may take type parameters, which are in scope in its bounds - private def typeDefSig(tpsym: Symbol, tparams: List[TypeDef], rhs: Tree) = { - val tparamSyms = typer.reenterTypeParams(tparams) //@M make tparams available in scope (just for this abstypedef) - val tp = typer.typedType(rhs).tpe match { - case TypeBounds(lt, rt) if (lt.isError || rt.isError) => - TypeBounds(NothingClass.tpe, AnyClass.tpe) - case tp @ TypeBounds(lt, rt) if (tpsym hasFlag JAVA) => - TypeBounds(lt, objToAny(rt)) - case tp => - tp - } - - def verifyOverriding(other: Symbol): Boolean = { - if(other.unsafeTypeParams.length != tparamSyms.length) { - context.error(tpsym.pos, - "The kind of "+tpsym.keyString+" "+tpsym.varianceString + tpsym.nameString+ - " does not conform to the expected kind of " + other.defString + other.locationString + ".") - false - } else true - } - - // @M: make sure overriding in refinements respects rudimentary kinding - // have to do this early, as otherwise we might get crashes: (see neg/bug1275.scala) - // suppose some parameterized type member is overridden by a type member w/o params, - // then appliedType will be called on a type that does not expect type args --> crash - if (tpsym.owner.isRefinementClass && // only needed in refinements - !tpsym.allOverriddenSymbols.forall{verifyOverriding(_)}) - ErrorType - else polyType(tparamSyms, tp) - } - - /** Given a case class - * - * case class C[Ts] (ps: Us) - * - * Add the following methods to toScope: - * - * 1. if case class is not abstract, add - * - * def apply[Ts](ps: Us): C[Ts] = new C[Ts](ps) - * - * 2. add a method - * - * def unapply[Ts](x: C[Ts]) = - * - * where is the caseClassUnapplyReturnValue of class C (see UnApplies.scala) - */ - def addApplyUnapply(cdef: ClassDef, namer: Namer) { - if (!(cdef.symbol hasFlag ABSTRACT)) - namer.enterSyntheticSym(caseModuleApplyMeth(cdef)) - namer.enterSyntheticSym(caseModuleUnapplyMeth(cdef)) - } - - def typeSig(tree: Tree): Type = { - val sym: Symbol = tree.symbol - tree match { - case defn: MemberDef => - val ainfos = for { - annot <- defn.mods.annotations - val ainfo = typer.typedAnnotation(annot, tree.symbol) - if !ainfo.atp.isError && annot != null - } yield ainfo - if (!ainfos.isEmpty) { - val annotated = if (sym.isModule) sym.moduleClass else sym - annotated.attributes = ainfos - } - case _ => - } - implicit val scopeKind = TypeSigScopeKind - val result = - try { - tree match { - case ClassDef(_, _, tparams, impl) => - newNamer(context.makeNewScope(tree, sym)).classSig(tparams, impl) - - case ModuleDef(_, _, impl) => - val clazz = sym.moduleClass - clazz.setInfo(newNamer(context.makeNewScope(tree, clazz)).templateSig(impl)) - //clazz.typeOfThis = singleType(sym.owner.thisType, sym); - clazz.tpe - - case DefDef(_, _, tparams, vparamss, tpt, rhs) => - //val result = - newNamer(context.makeNewScope(tree, sym)).methodSig(tparams, vparamss, tpt, rhs) - - case vdef @ ValDef(mods, _, tpt, rhs) => - val typer1 = typer.constrTyperIf(sym.hasFlag(PARAM | PRESUPER) && sym.owner.isConstructor) - if (tpt.isEmpty) { - if (rhs.isEmpty) { - context.error(tpt.pos, "missing parameter type"); - ErrorType - } else { - tpt.tpe = widenIfNotFinal( - sym, - newTyper(typer1.context.make(vdef, sym)).computeType(rhs, WildcardType), - WildcardType) - tpt setPos vdef.pos - tpt.tpe - } - } else typer1.typedType(tpt).tpe - - case TypeDef(_, _, tparams, rhs) => - newNamer(context.makeNewScope(tree, sym)).typeDefSig(sym, tparams, rhs) //@M! - - case Import(expr, selectors) => - val expr1 = typer.typedQualifier(expr) - val base = expr1.tpe - typer.checkStable(expr1) - if (expr1.symbol.isRootPackage) context.error(tree.pos, "_root_ cannot be imported") - def checkNotRedundant(pos: Position, from: Name, to: Name): Boolean = { - if (!tree.symbol.hasFlag(SYNTHETIC) && - !((expr1.symbol ne null) && expr1.symbol.isInterpreterWrapper) && - base.member(from) != NoSymbol) { - val e = context.scope.lookupEntryWithContext(to)(context.owner) - def warnRedundant(sym: Symbol) = - context.unit.warning(pos, "imported `"+to+ - "' is permanently hidden by definition of "+sym+ - sym.locationString) - if ((e ne null) && e.owner == context.scope) { - warnRedundant(e.sym); return false - } else if (context eq context.enclClass) { - val defSym = context.prefix.member(to) filter ( - sym => sym.exists && context.isAccessible(sym, context.prefix, false)) - if (defSym != NoSymbol) { warnRedundant(defSym); return false } - } - } - true - } - def checkSelectors(selectors: List[(Name, Name)]): Unit = selectors match { - case (from, to) :: rest => - if (from != nme.WILDCARD && base != ErrorType) { - if (base.member(from) == NoSymbol && base.member(from.toTypeName) == NoSymbol) - context.error(tree.pos, from.decode + " is not a member of " + expr); - if (checkNotRedundant(tree.pos, from, to)) - checkNotRedundant(tree.pos, from.toTypeName, to.toTypeName) - } - if (from != nme.WILDCARD && (rest.exists (sel => sel._1 == from))) - context.error(tree.pos, from.decode + " is renamed twice"); - if ((to ne null) && to != nme.WILDCARD && (rest exists (sel => sel._2 == to))) - context.error(tree.pos, to.decode + " appears twice as a target of a renaming"); - checkSelectors(rest) - case Nil => - } - checkSelectors(selectors) - ImportType(expr1) - } - } catch { - case ex: TypeError => - //Console.println("caught " + ex + " in typeSig")//DEBUG - typer.reportTypeError(tree.pos, ex) - ErrorType - } - result match { - case PolyType(tparams, restpe) - if (!tparams.isEmpty && tparams.head.owner.isTerm || - // Adriaan: The added conditon below is quite a hack. It seems that HK type parameters is relying - // on a pass that forces all infos in the type to get everything right. - // The problem is that the same pass causes cyclic reference errors in - // test pos/cyclics.scala. It turned out that deSkolemize is run way more often than necessary, - // ruinning it only when needed fixes the cuclic reference errors. - // But correcting deSkolemize broke HK types, because we don't do the traversal anymore. - // For the moment I made a special hack to do the traversal if we have HK type parameters. - // Maybe it's not a hack, then we need to document it better. But ideally, we should find - // a way to deal with HK types that's not dependent on accidental side - // effects like this. - tparams.exists(!_.typeParams.isEmpty)) => - new DeSkolemizeMap(tparams) mapOver result - case _ => -// println("not skolemizing "+result+" in "+context.owner) -// new DeSkolemizeMap(List()) mapOver result - result - } - } - - /** Check that symbol's definition is well-formed. This means: - * - no conflicting modifiers - * - `abstract' modifier only for classes - * - `override' modifier never for classes - * - `def' modifier never for parameters of case classes - * - declarations only in mixins or abstract classes (when not @native) - */ - def validate(sym: Symbol) { - def checkNoConflict(flag1: Int, flag2: Int) { - if (sym.hasFlag(flag1) && sym.hasFlag(flag2)) - context.error(sym.pos, - if (flag1 == DEFERRED) - "abstract member may not have " + Flags.flagsToString(flag2) + " modifier"; - else - "illegal combination of modifiers: " + - Flags.flagsToString(flag1) + " and " + Flags.flagsToString(flag2) + - " for: " + sym + Flags.flagsToString(sym.rawflags)); - } - - if (sym.hasFlag(IMPLICIT) && !sym.isTerm) - context.error(sym.pos, "`implicit' modifier can be used only for values, variables and methods") - if (sym.hasFlag(IMPLICIT) && sym.owner.isPackageClass && !inIDE) - context.error(sym.pos, "`implicit' modifier cannot be used for top-level objects") - if (sym.hasFlag(ABSTRACT) && !sym.isClass) - context.error(sym.pos, "`abstract' modifier can be used only for classes; " + - "\nit should be omitted for abstract members") - if (sym.hasFlag(OVERRIDE | ABSOVERRIDE) && !sym.hasFlag(TRAIT) && sym.isClass) - context.error(sym.pos, "`override' modifier not allowed for classes") - if (sym.hasFlag(OVERRIDE | ABSOVERRIDE) && sym.isConstructor) - context.error(sym.pos, "`override' modifier not allowed for constructors") - if (sym.hasFlag(ABSOVERRIDE) && !sym.owner.isTrait) - context.error(sym.pos, "`abstract override' modifier only allowed for members of traits") - if (sym.hasFlag(LAZY) && sym.hasFlag(PRESUPER)) - context.error(sym.pos, "`lazy' definitions may not be initialized early") - if (sym.info.typeSymbol == FunctionClass(0) && - sym.isValueParameter && sym.owner.isClass && sym.owner.hasFlag(CASE)) - context.error(sym.pos, "pass-by-name arguments not allowed for case class parameters"); - if (sym hasFlag DEFERRED) { // virtual classes count, too - if (sym.hasAttribute(definitions.NativeAttr)) - sym.resetFlag(DEFERRED) - else if (!sym.isValueParameter && !sym.isTypeParameterOrSkolem && - !context.tree.isInstanceOf[ExistentialTypeTree] && - (!sym.owner.isClass || sym.owner.isModuleClass || sym.owner.isAnonymousClass)) { - context.error(sym.pos, - "only classes can have declared but undefined members" + varNotice(sym)) - sym.resetFlag(DEFERRED) - } - } - - checkNoConflict(DEFERRED, PRIVATE) - checkNoConflict(FINAL, SEALED) - checkNoConflict(PRIVATE, PROTECTED) - checkNoConflict(PRIVATE, OVERRIDE) - /* checkNoConflict(PRIVATE, FINAL) // can't do this because FINAL also means compile-time constant */ - checkNoConflict(DEFERRED, FINAL) - } - } - - abstract class TypeCompleter extends LazyType { - val tree: Tree - } - - def mkTypeCompleter(t: Tree)(c: Symbol => Unit) = new TypeCompleter { - val tree = t - override def complete(sym: Symbol) = c(sym) - } - - /** A class representing a lazy type with known type parameters. - */ - class PolyTypeCompleter(tparams: List[Tree], restp: TypeCompleter, owner: Tree, ownerSym: Symbol, ctx: Context) extends TypeCompleter { - override val typeParams: List[Symbol]= tparams map (_.symbol) //@M - override val tree = restp.tree - override def complete(sym: Symbol) { - if(ownerSym.isAbstractType) //@M an abstract type's type parameters are entered -- TODO: change to isTypeMember ? - newNamer(ctx.makeNewScope(owner, ownerSym)(PolyTypeCompleterScopeKind)).enterSyms(tparams) //@M - restp.complete(sym) - } - } - - /** The symbol that which this accessor represents (possibly in part). - * This is used for error messages, where we want to speak in terms - * of the actual declaration or definition, not in terms of the generated setters - * and getters */ - def underlying(member: Symbol): Symbol = - if (member hasFlag ACCESSOR) { - if (member.isDeferred) { - val getter = if (member.isSetter) member.getter(member.owner) else member - if (inIDE && getter == NoSymbol) return NoSymbol; - val result = getter.owner.newValue(getter.pos, getter.name) - .setInfo(getter.tpe.resultType) - .setFlag(DEFERRED) - if (getter.setter(member.owner) != NoSymbol) result.setFlag(MUTABLE) - result - } else member.accessed - } else member - - /** An explanatory note to be added to error messages - * when there's a problem with abstract var defs */ - def varNotice(sym: Symbol): String = - if (underlying(sym).isVariable) - "\n(Note that variables need to be initialized to be defined)" - else "" -} - diff --git a/src/compiler/scala/tools/nsc/typechecker/Namers.scala.2 b/src/compiler/scala/tools/nsc/typechecker/Namers.scala.2 deleted file mode 100755 index bffde363c0..0000000000 --- a/src/compiler/scala/tools/nsc/typechecker/Namers.scala.2 +++ /dev/null @@ -1,1046 +0,0 @@ -/* NSC -- new Scala compiler - * Copyright 2005-2009 LAMP/EPFL - * @author Martin Odersky - */ -// $Id: Namers.scala 17114 2009-02-15 16:43:36Z odersky $ - -package scala.tools.nsc.typechecker - -import scala.collection.mutable.HashMap -import scala.tools.nsc.util.Position -import symtab.Flags -import symtab.Flags._ - -/** This trait declares methods to create symbols and to enter them into scopes. - * - * @author Martin Odersky - * @version 1.0 - */ -trait Namers { self: Analyzer => - import global._ - import definitions._ - import posAssigner.atPos - - /** Convert to corresponding type parameters all skolems of method parameters - * which appear in `tparams`. - */ - class DeSkolemizeMap(tparams: List[Symbol]) extends TypeMap { - def apply(tp: Type): Type = tp match { - case TypeRef(pre, sym, args) - if (sym.isTypeSkolem && (tparams contains sym.deSkolemize)) => -// println("DESKOLEMIZING "+sym+" in "+sym.owner) - mapOver(rawTypeRef(NoPrefix, sym.deSkolemize, args)) -/* - case PolyType(tparams1, restpe) => - new DeSkolemizeMap(tparams1 ::: tparams).mapOver(tp) - case ClassInfoType(parents, decls, clazz) => - val parents1 = List.mapConserve(parents)(this) - if (parents1 eq parents) tp else ClassInfoType(parents1, decls, clazz) -*/ - case _ => - mapOver(tp) - } - } - - private class NormalNamer(context : Context) extends Namer(context) - def newNamer(context : Context) : Namer = new NormalNamer(context) - - private[typechecker] val caseClassOfModuleClass = new HashMap[Symbol, ClassDef] - - def resetNamer() { - caseClassOfModuleClass.clear - } - - abstract class Namer(val context: Context) { - - val typer = newTyper(context) - - def setPrivateWithin[Sym <: Symbol](tree: Tree, sym: Sym, mods: Modifiers): Sym = { - if (!mods.privateWithin.isEmpty) - sym.privateWithin = typer.qualifyingClassContext(tree, mods.privateWithin, true).owner - sym - } - - def inConstructorFlag: Long = - if (context.owner.isConstructor && !context.inConstructorSuffix || context.owner.isEarly) INCONSTRUCTOR - else 0l - - def moduleClassFlags(moduleFlags: Long) = - (moduleFlags & ModuleToClassFlags) | FINAL | inConstructorFlag - - def updatePosFlags(sym: Symbol, pos: Position, flags: Long): Symbol = { - if (settings.debug.value) log("overwriting " + sym) - val lockedFlag = sym.flags & LOCKED - sym.reset(NoType) - sym setPos pos - sym.flags = flags | lockedFlag - if (sym.isModule && sym.moduleClass != NoSymbol) - updatePosFlags(sym.moduleClass, pos, moduleClassFlags(flags)) - if (sym.owner.isPackageClass && - (sym.linkedSym.rawInfo.isInstanceOf[loaders.SymbolLoader] || - sym.linkedSym.rawInfo.isComplete && runId(sym.validTo) != currentRunId)) - // pre-set linked symbol to NoType, in case it is not loaded together with this symbol. - sym.linkedSym.setInfo(NoType) - sym - } - - private def isTemplateContext(context: Context): Boolean = context.tree match { - case Template(_, _, _) => true - case Import(_, _) => isTemplateContext(context.outer) - case _ => false - } - - private var innerNamerCache: Namer = null - protected def makeConstructorScope(classContext : Context) : Context = { - val outerContext = classContext.outer.outer - outerContext.makeNewScope(outerContext.tree, outerContext.owner)(Constructor1ScopeKind) - } - - def namerOf(sym: Symbol): Namer = { - - def innerNamer: Namer = { - if (innerNamerCache eq null) - innerNamerCache = - if (!isTemplateContext(context)) this - else newNamer(context.make(context.tree, context.owner, scopeFor(context.tree, InnerScopeKind))) - innerNamerCache - } - - def primaryConstructorParamNamer: Namer = { //todo: can we merge this with SCCmode? - val classContext = context.enclClass - val paramContext = makeConstructorScope(classContext) - val unsafeTypeParams = context.owner.unsafeTypeParams - unsafeTypeParams foreach(sym => paramContext.scope.enter(sym)) - newNamer(paramContext) - } - if (sym.isTerm) { - if (sym.hasFlag(PARAM) && sym.owner.isPrimaryConstructor) - primaryConstructorParamNamer - else if (sym.hasFlag(PARAMACCESSOR) && !inIDE) - primaryConstructorParamNamer - else innerNamer - } else innerNamer - } - - protected def conflict(newS : Symbol, oldS : Symbol) : Boolean = { - (!oldS.isSourceMethod || - nme.isSetterName(newS.name) || - newS.owner.isPackageClass) && - !((newS.owner.isTypeParameter || newS.owner.isAbstractType) && - newS.name.length==1 && newS.name(0)=='_') //@M: allow repeated use of `_' for higher-order type params - } - - // IDE hook - protected def setInfo[Sym <: Symbol](sym : Sym)(tpe : LazyType) : Sym = sym.setInfo(tpe) - - private def doubleDefError(pos: Position, sym: Symbol) { - context.error(pos, - sym.name.toString() + " is already defined as " + - (if (sym.hasFlag(SYNTHETIC)) - "(compiler-generated) "+ (if (sym.isModule) "case class companion " else "") - else "") + - (if (sym.hasFlag(CASE)) "case class " + sym.name else sym.toString())) - } - - private def inCurrentScope(m: Symbol): Boolean = { - if (context.owner.isClass) context.owner == m.owner - else m.owner.isClass && context.scope == m.owner.info.decls - } - - def enterInScope(sym: Symbol): Symbol = enterInScope(sym, context.scope) - - def enterInScope(sym: Symbol, scope: Scope): Symbol = { - // allow for overloaded methods - if (!(sym.isSourceMethod && sym.owner.isClass && !sym.owner.isPackageClass)) { - var prev = scope.lookupEntryWithContext(sym.name)(context.owner); - if ((prev ne null) && inIDE) { - var guess = prev - while ((guess ne null) && (guess.sym ne sym)) guess = scope.lookupNextEntry(guess) - if (guess != null) prev = guess - while (prev != null && (!prev.sym.hasRawInfo || !prev.sym.rawInfo.isComplete || - (prev.sym.sourceFile == null && sym.getClass == prev.sym.getClass))) { - if (!prev.sym.hasRawInfo || prev.sym.rawInfo.isComplete) { - Console.println("DITCHING: " + prev.sym) - } - scope unlink prev.sym - prev = scope.lookupNextEntry(prev) - } - val sym0 = scope enter sym - if (sym0 ne sym) { - Console.println("WEIRD: " + sym0 + " vs. " + sym + " " + sym0.id + " " + sym.id + " " + sym.sourceFile + " " + sym0.sourceFile) - } - if (prev != null && (sym0 ne prev.sym) && conflict(sym0,prev.sym)) { - doubleDefError(sym0.pos, prev.sym) - } - sym0 - } else if ((prev ne null) && prev.owner == scope && conflict(sym, prev.sym)) { - doubleDefError(sym.pos, prev.sym) - sym setInfo ErrorType // don't do this in IDE for stability - scope unlink prev.sym // let them co-exist... - scope enter sym - } else scope enter sym - } else scope enter sym - } - - def enterPackageSymbol(pos: Position, name: Name): Symbol = { - val (cscope, cowner) = - if (context.owner == EmptyPackageClass) (RootClass.info.decls, RootClass) - else (context.scope, context.owner) - val p: Symbol = cscope.lookupWithContext(name)(context.owner) - if (p.isPackage && cscope == p.owner.info.decls) { - p - } else { - val pkg = cowner.newPackage(pos, name) - // IDE: newScope should be ok because packages are never destroyed. - if (inIDE) assert(!pkg.moduleClass.hasRawInfo || !pkg.moduleClass.rawInfo.isComplete) - pkg.moduleClass.setInfo(new PackageClassInfoType(newScope, pkg.moduleClass, null)) - pkg.setInfo(pkg.moduleClass.tpe) - enterInScope(pkg, cscope) - } - } - - def enterClassSymbol(tree : ClassDef): Symbol = { - var c: Symbol = context.scope.lookupWithContext(tree.name)(context.owner); - if (!inIDE && c.isType && c.owner.isPackageClass && context.scope == c.owner.info.decls && !currentRun.compiles(c)) { - updatePosFlags(c, tree.pos, tree.mods.flags) - setPrivateWithin(tree, c, tree.mods) - } else { - var sym = context.owner.newClass(tree.pos, tree.name) - sym = sym.setFlag(tree.mods.flags | inConstructorFlag) - sym = setPrivateWithin(tree, sym, tree.mods) - c = enterInScope(sym) - } - if (c.owner.isPackageClass) { - val file = context.unit.source.file - val clazz = c.asInstanceOf[ClassSymbol] - if (settings.debug.value && (clazz.sourceFile ne null) && !clazz.sourceFile.equals(file)) { - Console.err.println("SOURCE MISMATCH: " + clazz.sourceFile + " vs. " + file + " SYM=" + c); - } - clazz.sourceFile = file - if (clazz.sourceFile ne null) { - assert(inIDE || !currentRun.compiles(clazz) || clazz.sourceFile == currentRun.symSource(c)); - currentRun.symSource(c) = clazz.sourceFile - } - } - assert(c.name.toString.indexOf('(') == -1) - c - } - - /** Enter a module symbol. The tree parameter can be either a module definition - * or a class definition */ - def enterModuleSymbol(tree : ModuleDef): Symbol = { - // .pos, mods.flags | MODULE | FINAL, name - var m: Symbol = context.scope.lookupWithContext(tree.name)(context.owner) - val moduleFlags = tree.mods.flags | MODULE | FINAL - if (m.isModule && !m.isPackage && inCurrentScope(m) && - ((!inIDE && !currentRun.compiles(m)) || (m hasFlag SYNTHETIC))) { - updatePosFlags(m, tree.pos, moduleFlags) - setPrivateWithin(tree, m, tree.mods) - context.unit.synthetics -= m - } else { - m = context.owner.newModule(tree.pos, tree.name) - m.setFlag(moduleFlags) - m = setPrivateWithin(tree, m, tree.mods) - m = enterInScope(m) - - m.moduleClass.setFlag(moduleClassFlags(moduleFlags)) - setPrivateWithin(tree, m.moduleClass, tree.mods) - } - if (m.owner.isPackageClass) { - m.moduleClass.sourceFile = context.unit.source.file - currentRun.symSource(m) = m.moduleClass.sourceFile - } - m - } - - def enterSyms(trees: List[Tree]): Namer = { - var namer : Namer = this - for (tree <- trees) { - val txt = namer.enterSym(tree) - if (!(txt eq namer.context)) namer = newNamer(txt) - } - namer - } - - def newTypeSkolems(tparams: List[Symbol]): List[Symbol] = { - val tskolems = tparams map (_.newTypeSkolem) - val ltp = new LazyType { - override def complete(sym: Symbol) { - sym setInfo sym.deSkolemize.info.substSym(tparams, tskolems) //@M the info of a skolem is the skolemized info of the actual type parameter of the skolem - } - } - tskolems foreach (_.setInfo(ltp)) - tskolems - } - - /** Replace type parameters with their TypeSkolems, which can later be deskolemized to the original type param - * (a skolem is a representation of a bound variable when viewed inside its scope) - */ - def skolemize(tparams: List[TypeDef]) { - val tskolems = newTypeSkolems(tparams map (_.symbol)) - for ((tparam, tskolem) <- tparams zip tskolems) tparam.symbol = tskolem - } - - def applicableTypeParams(owner: Symbol): List[Symbol] = - if (inIDE && (owner eq NoSymbol)) List() - else if (owner.isTerm || owner.isPackageClass) List() - else applicableTypeParams(owner.owner) ::: owner.typeParams - - def enterSym(tree: Tree): Context = try { - - def finishWith(tparams: List[TypeDef]) { - val sym = tree.symbol - if (settings.debug.value) log("entered " + sym + " in " + context.owner + ", scope-id = " + context.scope.hashCode()); - var ltype = namerOf(sym).typeCompleter(tree) - if (!tparams.isEmpty) { - //@M! TypeDef's type params are handled differently - //@M e.g., in [A[x <: B], B], A and B are entered first as both are in scope in the definition of x - //@M x is only in scope in `A[x <: B]' - if(!sym.isAbstractType) //@M TODO: change to isTypeMember ? - newNamer(context.makeNewScope(tree, sym)(FinishWithScopeKind)).enterSyms(tparams) - ltype = new PolyTypeCompleter(tparams, ltype, tree, sym, context) //@M - if (sym.isTerm) skolemize(tparams) - } - setInfo(sym)(ltype) - } - def finish = finishWith(List()) - - if (tree.symbol == NoSymbol) { - val owner = context.owner - tree match { - case PackageDef(name, stats) => - tree.symbol = enterPackageSymbol(tree.pos, name) - val namer = newNamer( - context.make(tree, tree.symbol.moduleClass, tree.symbol.info.decls)) - namer.enterSyms(stats) - case tree @ ClassDef(mods, name, tparams, impl) => - tree.symbol = enterClassSymbol(tree) - finishWith(tparams) - if ((mods.flags & CASE) != 0) { - var m: Symbol = context.scope.lookupWithContext(tree.name.toTermName)(context.owner).filter(! _.isSourceMethod) - if (!(m.isModule && inCurrentScope(m) && (inIDE || currentRun.compiles(m)))) { - m = enterSyntheticSym(caseModuleDef(tree)) - } - caseClassOfModuleClass(m.moduleClass) = tree - } - case tree @ ModuleDef(mods, name, _) => - tree.symbol = enterModuleSymbol(tree) - tree.symbol.moduleClass.setInfo(namerOf(tree.symbol).moduleClassTypeCompleter((tree))) - finish - - case ValDef(mods, name, tp, rhs) => - if ((!context.owner.isClass || - (mods.flags & (PRIVATE | LOCAL)) == (PRIVATE | LOCAL) || - name.endsWith(nme.OUTER, nme.OUTER.length) || - context.unit.isJava) && - (mods.flags & LAZY) == 0) { - tree.symbol = enterInScope(owner.newValue(tree.pos, name) - .setFlag(mods.flags)) - finish - } else { - // add getter and possibly also setter - val accflags: Long = ACCESSOR | - (if ((mods.flags & MUTABLE) != 0) mods.flags & ~MUTABLE & ~PRESUPER - else mods.flags & ~PRESUPER | STABLE) - if (nme.isSetterName(name)) - context.error(tree.pos, "Names of vals or vars may not end in `_='") - var getter = owner.newMethod(tree.pos, name).setFlag(accflags) - setPrivateWithin(tree, getter, mods) - getter = enterInScope(getter).asInstanceOf[TermSymbol] - setInfo(getter)(namerOf(getter).getterTypeCompleter(tree)) - if ((mods.flags & MUTABLE) != 0) { - var setter = owner.newMethod(tree.pos, nme.getterToSetter(name)) - .setFlag(accflags & ~STABLE & ~CASEACCESSOR) - setPrivateWithin(tree, setter, mods) - setter = enterInScope(setter).asInstanceOf[TermSymbol] - setInfo(setter)(namerOf(setter).setterTypeCompleter(tree)) - } - tree.symbol = - if ((mods.flags & DEFERRED) == 0) { - var vsym = - if (!context.owner.isClass) { - assert((mods.flags & LAZY) != 0) // if not a field, it has to be a lazy val - owner.newValue(tree.pos, name + "$lzy" ).setFlag(mods.flags | MUTABLE) - } else { - owner.newValue(tree.pos, nme.getterToLocal(name)) - .setFlag(mods.flags & FieldFlags | PRIVATE | LOCAL | (if ((mods.flags & LAZY) != 0) MUTABLE else 0)) - } - vsym = enterInScope(vsym).asInstanceOf[TermSymbol] - setInfo(vsym)(namerOf(vsym).typeCompleter(tree)) - if ((mods.flags & LAZY) != 0) - vsym.setLazyAccessor(getter) - vsym - } else getter - } - case DefDef(mods, nme.CONSTRUCTOR, tparams, _, _, _) => - var sym = owner.newConstructor(tree.pos).setFlag(mods.flags | owner.getFlag(ConstrFlags)) - setPrivateWithin(tree, sym, mods) - tree.symbol = enterInScope(sym) - finishWith(tparams) - case DefDef(mods, name, tparams, _, _, _) => - var sym = (owner.newMethod(tree.pos, name)).setFlag(mods.flags) - setPrivateWithin(tree, sym, mods) - tree.symbol = enterInScope(sym) - finishWith(tparams) - case TypeDef(mods, name, tparams, _) => - var flags: Long = mods.flags - if ((flags & PARAM) != 0) flags |= DEFERRED - var sym = new TypeSymbol(owner, tree.pos, name).setFlag(flags) - setPrivateWithin(tree, sym, mods) - tree.symbol = enterInScope(sym) - finishWith(tparams) - case DocDef(_, defn) => - enterSym(defn) - case imp @ Import(_, _) => - tree.symbol = NoSymbol.newImport(tree.pos) - setInfo(tree.symbol)(namerOf(tree.symbol).typeCompleter(tree)) - return (context.makeNewImport(imp)) - case _ => - } - } - this.context - } catch { - case ex: TypeError => - //Console.println("caught " + ex + " in enterSym")//DEBUG - typer.reportTypeError(tree.pos, ex) - this.context - } - - def enterSyntheticSym(tree: Tree): Symbol = { - enterSym(tree) - context.unit.synthetics(tree.symbol) = tree - tree.symbol - } - -// --- Lazy Type Assignment -------------------------------------------------- - - def typeCompleter(tree: Tree) = mkTypeCompleter(tree) { sym => - if (settings.debug.value) log("defining " + sym + Flags.flagsToString(sym.flags)+sym.locationString) - val tp = typeSig(tree) - tp match { - case TypeBounds(lo, hi) => - // check that lower bound is not an F-bound - for (val t <- lo) { - t match { - case TypeRef(_, sym, _) => sym.initialize - case _ => - } - } - case _ => - } - sym.setInfo(tp) - if ((sym.isAliasType || sym.isAbstractType) && !(sym hasFlag PARAM) && - !typer.checkNonCyclic(tree.pos, tp)) - sym.setInfo(ErrorType) // this early test is there to avoid infinite baseTypes when - // adding setters and getters --> bug798 - if (settings.debug.value) log("defined " + sym); - validate(sym) - } - - def moduleClassTypeCompleter(tree: Tree) = { - mkTypeCompleter(tree) { sym => - val moduleSymbol = tree.symbol - assert(moduleSymbol.moduleClass == sym) - if (inIDE && moduleSymbol.rawInfo.isComplete) { - // reset! - } - moduleSymbol.info // sets moduleClass info as a side effect. - //assert(sym.rawInfo.isComplete) - } - } - - def getterTypeCompleter(tree: Tree) = mkTypeCompleter(tree) { sym => - if (settings.debug.value) log("defining " + sym) - sym.setInfo(PolyType(List(), typeSig(tree))) - if (settings.debug.value) log("defined " + sym) - validate(sym) - } - - def setterTypeCompleter(tree: Tree) = mkTypeCompleter(tree) { sym => - if (settings.debug.value) log("defining " + sym); - sym.setInfo(MethodType(List(typeSig(tree)), UnitClass.tpe)) - if (settings.debug.value) log("defined " + sym); - validate(sym) - } - - def selfTypeCompleter(tree: Tree) = mkTypeCompleter(tree) { sym => - var selftpe = typer.typedType(tree).tpe - if (!(selftpe.typeSymbol isNonBottomSubClass sym.owner)) - selftpe = intersectionType(List(sym.owner.tpe, selftpe)) -// println("completing self of "+sym.owner+": "+selftpe) - sym.setInfo(selftpe) - } - - private def widenIfNotFinal(sym: Symbol, tpe: Type, pt: Type): Type = { - val getter = - if (sym.isValue && sym.owner.isClass && (sym hasFlag PRIVATE)) - sym.getter(sym.owner) - else sym - def isHidden(tp: Type): Boolean = tp match { - case SingleType(pre, sym) => - (sym isLessAccessibleThan getter) || isHidden(pre) - case ThisType(sym) => - sym isLessAccessibleThan getter - case p: SimpleTypeProxy => - isHidden(p.underlying) - case _ => - false - } - val tpe1 = tpe.deconst - val tpe2 = tpe1.widen - if ((sym.isVariable || sym.isMethod && !(sym hasFlag ACCESSOR))) - if (tpe2 <:< pt) tpe2 else tpe1 - else if (isHidden(tpe)) tpe2 - else if (!(sym hasFlag FINAL)) tpe1 - else tpe - } - - def enterValueParams(owner: Symbol, vparamss: List[List[ValDef]]): List[List[Symbol]] = { - def enterValueParam(param: ValDef): Symbol = { - if (inIDE) param.symbol = { - var sym = owner.newValueParameter(param.pos, param.name). - setFlag(param.mods.flags & (BYNAMEPARAM | IMPLICIT)) - setPrivateWithin(param, sym, param.mods) - sym = enterInScope(sym).asInstanceOf[TermSymbol] - if (!sym.hasRawInfo || sym.rawInfo.isComplete) - setInfo(sym)(typeCompleter(param)) - sym - } else param.symbol = setInfo( - enterInScope{ - val sym = owner.newValueParameter(param.pos, param.name). - setFlag(param.mods.flags & (BYNAMEPARAM | IMPLICIT)) - setPrivateWithin(param, sym, param.mods) - })(typeCompleter(param)) - param.symbol - } - vparamss.map(_.map(enterValueParam)) - } - - private def templateSig(templ: Template): Type = { - val clazz = context.owner - def checkParent(tpt: Tree): Type = { - val tp = tpt.tpe - if (tp.typeSymbol == context.owner) { - context.error(tpt.pos, ""+tp.typeSymbol+" inherits itself") - AnyRefClass.tpe - } else if (tp.isError) { - AnyRefClass.tpe - } else { - tp - } - } - def enterSelf(self: ValDef) { - if (!self.tpt.isEmpty) { - clazz.typeOfThis = selfTypeCompleter(self.tpt) - self.symbol = clazz.thisSym.setPos(self.pos) - } else { - self.tpt.tpe = NoType - if (self.name != nme.WILDCARD) { - clazz.typeOfThis = clazz.tpe - self.symbol = clazz.thisSym - } else if (self ne emptyValDef) { - self.symbol = clazz.newThisSym(self.pos) setInfo clazz.tpe - } - } - if (self.name != nme.WILDCARD) { - self.symbol.name = self.name - self.symbol = context.scope enter self.symbol - } - } - var parents = typer.parentTypes(templ) map checkParent - enterSelf(templ.self) - val decls = newClassScope(clazz) - val templateNamer = newNamer(context.make(templ, clazz, decls)) - .enterSyms(templ.body) - - /* add overridden virtuals to parents - val overridden = clazz.overriddenVirtuals - if (!overridden.isEmpty) - parents = parents ::: ( overridden map ( - sym => TypeRef(clazz.owner.thisType, sym, clazz.typeParams map (_.tpe)))) - println("Parents of "+clazz+":"+parents) - - // check that virtual classses are only defined as members of templates - if (clazz.isVirtualClass && !clazz.owner.isClass) - context.error( - clazz.pos, - "virtual traits and their subclasses must be defined as members of some other class") - - // make subclasses of virtual classes virtual as well; check that - // they are defined in same scope. - val virtualParents = parents map (_.typeSymbol) filter (_.isVirtualClass) - virtualParents find { - vp => !(clazz.owner.isClass && (clazz.owner isSubClass vp.owner)) - } match { - case Some(vp) => - context.error( - clazz.pos, - "subclass of virtual "+vp+ - " needs to be defined at same level,\nas member of "+vp.owner) - case None => - if (!virtualParents.isEmpty) clazz setFlag DEFERRED // make it virtual - } - */ - - // add apply and unapply methods to companion objects of case classes, - // unless they exist already - Namers.this.caseClassOfModuleClass get clazz match { - case Some(cdef) => - val go = if (inIDE) { // garbage collect in the presentaiton compiler. - assert(cdef.symbol != null && cdef.symbol != NoSymbol) - if (!cdef.symbol.isClass || !cdef.symbol.hasFlag(CASE) || cdef.symbol.rawInfo == NoType) false - else true - } else true - if (go) - addApplyUnapply(cdef, templateNamer) - if (!go || !inIDE) caseClassOfModuleClass -= clazz - if (!go) { - val rem = clazz.linkedModuleOfClass - assert(rem != NoSymbol) - } - case None => - } - ClassInfoType(parents, decls, clazz) - } - - private def classSig(tparams: List[TypeDef], impl: Template): Type = - polyType(typer.reenterTypeParams(tparams), templateSig(impl)) - - private def methodSig(tparams: List[TypeDef], vparamss: List[List[ValDef]], - tpt: Tree, rhs: Tree): Type = { - val meth = context.owner - - val tparamSyms = typer.reenterTypeParams(tparams) - var vparamSymss = - if (inIDE && meth.isPrimaryConstructor) { - // @S: because they have already been entered this way.... - - enterValueParams(meth.owner.owner, vparamss) - } else { - enterValueParams(meth, vparamss) - } - if (tpt.isEmpty && meth.name == nme.CONSTRUCTOR) { - tpt.tpe = context.enclClass.owner.tpe - tpt setPos meth.pos - } - - if (onlyPresentation && methodArgumentNames != null) - methodArgumentNames(meth) = vparamss.map(_.map(_.symbol)); - - def convertToDeBruijn(vparams: List[Symbol], level: Int): TypeMap = new TypeMap { - def debruijnFor(param: Symbol) = - DeBruijnIndex(level, vparams indexOf param) - def apply(tp: Type) = { - tp match { - case SingleType(_, sym) => - if (settings.Xexperimental.value && sym.owner == meth && (vparams contains sym)) { -/* - if (sym hasFlag IMPLICIT) { - context.error(sym.pos, "illegal type dependence on implicit parameter") - ErrorType - } else -*/ - debruijnFor(sym) - } else tp - case MethodType(formals, restpe) => - val formals1 = List.mapConserve(formals)(this) - val restpe1 = convertToDeBruijn(vparams, level + 1)(restpe) - if ((formals1 eq formals) && (restpe1 eq restpe)) tp - else copyMethodType(tp, formals1, restpe1) - case _ => - mapOver(tp) - } - } - - object treeTrans extends TypeMapTransformer { - override def transform(tree: Tree): Tree = - tree match { - case Ident(name) if (vparams contains tree.symbol) => - val dtpe = debruijnFor(tree.symbol) - val dsym = - newLocalDummy(context.owner, tree.symbol.pos) - .newValue(tree.symbol.pos, name) - - dsym.setFlag(PARAM) - dsym.setInfo(dtpe) - Ident(name).setSymbol(dsym).copyAttrs(tree).setType(dtpe) - case tree => super.transform(tree) - } - } - - override def mapOver(arg: Tree) = Some(treeTrans.transform(arg)) - } - - val checkDependencies: TypeTraverser = new TypeTraverser { - def traverse(tp: Type) = { - tp match { - case SingleType(_, sym) => - if (sym.owner == meth && (vparamSymss exists (_ contains sym))) - context.error( - sym.pos, - "illegal dependent method type"+ - (if (settings.Xexperimental.value) - ": parameter appears in the type of another parameter in the same section or an earlier one" - else "")) - case _ => - mapOver(tp) - } - this - } - } - - def makeMethodType(vparams: List[Symbol], restpe: Type) = { - val formals = vparams map (vparam => - if (meth hasFlag JAVA) objToAny(vparam.tpe) else vparam.tpe) - val restpe1 = convertToDeBruijn(vparams, 1)(restpe) - if (!vparams.isEmpty && vparams.head.hasFlag(IMPLICIT)) - ImplicitMethodType(formals, restpe1) - else if (meth hasFlag JAVA) JavaMethodType(formals, restpe1) - else MethodType(formals, restpe1) - } - - def thisMethodType(restpe: Type) = - polyType( - tparamSyms, - if (vparamSymss.isEmpty) PolyType(List(), restpe) - else checkDependencies((vparamSymss :\ restpe) (makeMethodType))) - - var resultPt = if (tpt.isEmpty) WildcardType else typer.typedType(tpt).tpe - val site = meth.owner.thisType - - def overriddenSymbol = intersectionType(meth.owner.info.parents).member(meth.name).filter(sym => - sym != NoSymbol && (site.memberType(sym) matches thisMethodType(resultPt))) - - // fill in result type and parameter types from overridden symbol if there is a unique one. - if (meth.owner.isClass && (tpt.isEmpty || vparamss.exists(_.exists(_.tpt.isEmpty)))) { - // try to complete from matching definition in base type - for (vparams <- vparamss; vparam <- vparams) - if (vparam.tpt.isEmpty) vparam.symbol setInfo WildcardType - val overridden = overriddenSymbol - if (overridden != NoSymbol && !(overridden hasFlag OVERLOADED)) { - resultPt = site.memberType(overridden) match { - case PolyType(tparams, rt) => rt.substSym(tparams, tparamSyms) - case mt => mt - } - - for (vparams <- vparamss) { - var pfs = resultPt.paramTypes - for (vparam <- vparams) { - if (vparam.tpt.isEmpty) { - vparam.tpt.tpe = pfs.head - vparam.tpt setPos vparam.pos - vparam.symbol setInfo pfs.head - } - pfs = pfs.tail - } - resultPt = resultPt.resultType - } - resultPt match { - case PolyType(List(), rtpe) => resultPt = rtpe - case MethodType(List(), rtpe) => resultPt = rtpe - case _ => - } - if (tpt.isEmpty) { - // provisionally assign `meth' a method type with inherited result type - // that way, we can leave out the result type even if method is recursive. - meth setInfo thisMethodType(resultPt) - } - } - } - // Add a () parameter section if this overrides dome method with () parameters. - if (meth.owner.isClass && vparamss.isEmpty && overriddenSymbol.alternatives.exists( - _.info.isInstanceOf[MethodType])) { - vparamSymss = List(List()) - } - for (vparams <- vparamss; vparam <- vparams if vparam.tpt.isEmpty) { - context.error(vparam.pos, "missing parameter type") - vparam.tpt.tpe = ErrorType - } - - thisMethodType( - if (tpt.isEmpty) { - val pt = resultPt.substSym(tparamSyms, tparams map (_.symbol)) - tpt.tpe = widenIfNotFinal(meth, typer.computeType(rhs, pt), pt) - tpt setPos meth.pos - tpt.tpe - } else typer.typedType(tpt).tpe) - } - - //@M! an abstract type definition (abstract type member/type parameter) may take type parameters, which are in scope in its bounds - private def typeDefSig(tpsym: Symbol, tparams: List[TypeDef], rhs: Tree) = { - val tparamSyms = typer.reenterTypeParams(tparams) //@M make tparams available in scope (just for this abstypedef) - val tp = typer.typedType(rhs).tpe match { - case TypeBounds(lt, rt) if (lt.isError || rt.isError) => - TypeBounds(NothingClass.tpe, AnyClass.tpe) - case tp @ TypeBounds(lt, rt) if (tpsym hasFlag JAVA) => - TypeBounds(lt, objToAny(rt)) - case tp => - tp - } - - def verifyOverriding(other: Symbol): Boolean = { - if(other.unsafeTypeParams.length != tparamSyms.length) { - context.error(tpsym.pos, - "The kind of "+tpsym.keyString+" "+tpsym.varianceString + tpsym.nameString+ - " does not conform to the expected kind of " + other.defString + other.locationString + ".") - false - } else true - } - - // @M: make sure overriding in refinements respects rudimentary kinding - // have to do this early, as otherwise we might get crashes: (see neg/bug1275.scala) - // suppose some parameterized type member is overridden by a type member w/o params, - // then appliedType will be called on a type that does not expect type args --> crash - if (tpsym.owner.isRefinementClass && // only needed in refinements - !tpsym.allOverriddenSymbols.forall{verifyOverriding(_)}) - ErrorType - else polyType(tparamSyms, tp) - } - - /** Given a case class - * - * case class C[Ts] (ps: Us) - * - * Add the following methods to toScope: - * - * 1. if case class is not abstract, add - * - * def apply[Ts](ps: Us): C[Ts] = new C[Ts](ps) - * - * 2. add a method - * - * def unapply[Ts](x: C[Ts]) = - * - * where is the caseClassUnapplyReturnValue of class C (see UnApplies.scala) - */ - def addApplyUnapply(cdef: ClassDef, namer: Namer) { - if (!(cdef.symbol hasFlag ABSTRACT)) - namer.enterSyntheticSym(caseModuleApplyMeth(cdef)) - namer.enterSyntheticSym(caseModuleUnapplyMeth(cdef)) - } - - def typeSig(tree: Tree): Type = { - val sym: Symbol = tree.symbol - tree match { - case defn: MemberDef => - val ainfos = for { - annot <- defn.mods.annotations - val ainfo = typer.typedAnnotation(annot, tree.symbol) - if !ainfo.atp.isError && annot != null - } yield ainfo - if (!ainfos.isEmpty) { - val annotated = if (sym.isModule) sym.moduleClass else sym - annotated.attributes = ainfos - } - case _ => - } - implicit val scopeKind = TypeSigScopeKind - val result = - try { - tree match { - case ClassDef(_, _, tparams, impl) => - newNamer(context.makeNewScope(tree, sym)).classSig(tparams, impl) - - case ModuleDef(_, _, impl) => - val clazz = sym.moduleClass - clazz.setInfo(newNamer(context.makeNewScope(tree, clazz)).templateSig(impl)) - //clazz.typeOfThis = singleType(sym.owner.thisType, sym); - clazz.tpe - - case DefDef(_, _, tparams, vparamss, tpt, rhs) => - //val result = - newNamer(context.makeNewScope(tree, sym)).methodSig(tparams, vparamss, tpt, rhs) - - case vdef @ ValDef(mods, _, tpt, rhs) => - val typer1 = typer.constrTyperIf(sym.hasFlag(PARAM | PRESUPER) && sym.owner.isConstructor) - if (tpt.isEmpty) { - if (rhs.isEmpty) { - context.error(tpt.pos, "missing parameter type"); - ErrorType - } else { - tpt.tpe = widenIfNotFinal( - sym, - newTyper(typer1.context.make(vdef, sym)).computeType(rhs, WildcardType), - WildcardType) - tpt setPos vdef.pos - tpt.tpe - } - } else typer1.typedType(tpt).tpe - - case TypeDef(_, _, tparams, rhs) => - newNamer(context.makeNewScope(tree, sym)).typeDefSig(sym, tparams, rhs) //@M! - - case Import(expr, selectors) => - val expr1 = typer.typedQualifier(expr) - val base = expr1.tpe - typer.checkStable(expr1) - if (expr1.symbol.isRootPackage) context.error(tree.pos, "_root_ cannot be imported") - def checkNotRedundant(pos: Position, from: Name, to: Name): Boolean = { - if (!tree.symbol.hasFlag(SYNTHETIC) && - !((expr1.symbol ne null) && expr1.symbol.isInterpreterWrapper) && - base.member(from) != NoSymbol) { - val e = context.scope.lookupEntryWithContext(to)(context.owner) - def warnRedundant(sym: Symbol) = - context.unit.warning(pos, "imported `"+to+ - "' is permanently hidden by definition of "+sym+ - sym.locationString) - if ((e ne null) && e.owner == context.scope) { - warnRedundant(e.sym); return false - } else if (context eq context.enclClass) { - val defSym = context.prefix.member(to) filter ( - sym => sym.exists && context.isAccessible(sym, context.prefix, false)) - if (defSym != NoSymbol) { warnRedundant(defSym); return false } - } - } - true - } - def checkSelectors(selectors: List[(Name, Name)]): Unit = selectors match { - case (from, to) :: rest => - if (from != nme.WILDCARD && base != ErrorType) { - if (base.member(from) == NoSymbol && base.member(from.toTypeName) == NoSymbol) - context.error(tree.pos, from.decode + " is not a member of " + expr); - if (checkNotRedundant(tree.pos, from, to)) - checkNotRedundant(tree.pos, from.toTypeName, to.toTypeName) - } - if (from != nme.WILDCARD && (rest.exists (sel => sel._1 == from))) - context.error(tree.pos, from.decode + " is renamed twice"); - if ((to ne null) && to != nme.WILDCARD && (rest exists (sel => sel._2 == to))) - context.error(tree.pos, to.decode + " appears twice as a target of a renaming"); - checkSelectors(rest) - case Nil => - } - checkSelectors(selectors) - ImportType(expr1) - } - } catch { - case ex: TypeError => - //Console.println("caught " + ex + " in typeSig")//DEBUG - typer.reportTypeError(tree.pos, ex) - ErrorType - } - result match { - case PolyType(tparams, restpe) - if (!tparams.isEmpty && tparams.head.owner.isTerm || - // Adriaan: The added conditon below is quite a hack. It seems that HK type parameters is relying - // on a pass that forces all infos in the type to get everything right. - // The problem is that the same pass causes cyclic reference errors in - // test pos/cyclics.scala. It turned out that deSkolemize is run way more often than necessary, - // ruinning it only when needed fixes the cuclic reference errors. - // But correcting deSkolemize broke HK types, because we don't do the traversal anymore. - // For the moment I made a special hack to do the traversal if we have HK type parameters. - // Maybe it's not a hack, then we need to document it better. But ideally, we should find - // a way to deal with HK types that's not dependent on accidental side - // effects like this. - tparams.exists(!_.typeParams.isEmpty)) => - new DeSkolemizeMap(tparams) mapOver result - case _ => -// println("not skolemizing "+result+" in "+context.owner) -// new DeSkolemizeMap(List()) mapOver result - result - } - } - - /** Check that symbol's definition is well-formed. This means: - * - no conflicting modifiers - * - `abstract' modifier only for classes - * - `override' modifier never for classes - * - `def' modifier never for parameters of case classes - * - declarations only in mixins or abstract classes (when not @native) - */ - def validate(sym: Symbol) { - def checkNoConflict(flag1: Int, flag2: Int) { - if (sym.hasFlag(flag1) && sym.hasFlag(flag2)) - context.error(sym.pos, - if (flag1 == DEFERRED) - "abstract member may not have " + Flags.flagsToString(flag2) + " modifier"; - else - "illegal combination of modifiers: " + - Flags.flagsToString(flag1) + " and " + Flags.flagsToString(flag2) + - " for: " + sym + Flags.flagsToString(sym.rawflags)); - } - - if (sym.hasFlag(IMPLICIT) && !sym.isTerm) - context.error(sym.pos, "`implicit' modifier can be used only for values, variables and methods") - if (sym.hasFlag(IMPLICIT) && sym.owner.isPackageClass && !inIDE) - context.error(sym.pos, "`implicit' modifier cannot be used for top-level objects") - if (sym.hasFlag(ABSTRACT) && !sym.isClass) - context.error(sym.pos, "`abstract' modifier can be used only for classes; " + - "\nit should be omitted for abstract members") - if (sym.hasFlag(OVERRIDE | ABSOVERRIDE) && !sym.hasFlag(TRAIT) && sym.isClass) - context.error(sym.pos, "`override' modifier not allowed for classes") - if (sym.hasFlag(OVERRIDE | ABSOVERRIDE) && sym.isConstructor) - context.error(sym.pos, "`override' modifier not allowed for constructors") - if (sym.hasFlag(ABSOVERRIDE) && !sym.owner.isTrait) - context.error(sym.pos, "`abstract override' modifier only allowed for members of traits") - if (sym.hasFlag(LAZY) && sym.hasFlag(PRESUPER)) - context.error(sym.pos, "`lazy' definitions may not be initialized early") - if (sym.info.typeSymbol == FunctionClass(0) && - sym.isValueParameter && sym.owner.isClass && sym.owner.hasFlag(CASE)) - context.error(sym.pos, "pass-by-name arguments not allowed for case class parameters"); - if (sym hasFlag DEFERRED) { // virtual classes count, too - if (sym.hasAttribute(definitions.NativeAttr)) - sym.resetFlag(DEFERRED) - else if (!sym.isValueParameter && !sym.isTypeParameterOrSkolem && - !context.tree.isInstanceOf[ExistentialTypeTree] && - (!sym.owner.isClass || sym.owner.isModuleClass || sym.owner.isAnonymousClass)) { - context.error(sym.pos, - "only classes can have declared but undefined members" + varNotice(sym)) - sym.resetFlag(DEFERRED) - } - } - - checkNoConflict(DEFERRED, PRIVATE) - checkNoConflict(FINAL, SEALED) - checkNoConflict(PRIVATE, PROTECTED) - checkNoConflict(PRIVATE, OVERRIDE) - /* checkNoConflict(PRIVATE, FINAL) // can't do this because FINAL also means compile-time constant */ - checkNoConflict(DEFERRED, FINAL) - } - } - - abstract class TypeCompleter extends LazyType { - val tree: Tree - } - - def mkTypeCompleter(t: Tree)(c: Symbol => Unit) = new TypeCompleter { - val tree = t - override def complete(sym: Symbol) = c(sym) - } - - /** A class representing a lazy type with known type parameters. - */ - class PolyTypeCompleter(tparams: List[Tree], restp: TypeCompleter, owner: Tree, ownerSym: Symbol, ctx: Context) extends TypeCompleter { - override val typeParams: List[Symbol]= tparams map (_.symbol) //@M - override val tree = restp.tree - override def complete(sym: Symbol) { - if(ownerSym.isAbstractType) //@M an abstract type's type parameters are entered -- TODO: change to isTypeMember ? - newNamer(ctx.makeNewScope(owner, ownerSym)(PolyTypeCompleterScopeKind)).enterSyms(tparams) //@M - restp.complete(sym) - } - } - - /** The symbol that which this accessor represents (possibly in part). - * This is used for error messages, where we want to speak in terms - * of the actual declaration or definition, not in terms of the generated setters - * and getters */ - def underlying(member: Symbol): Symbol = - if (member hasFlag ACCESSOR) { - if (member.isDeferred) { - val getter = if (member.isSetter) member.getter(member.owner) else member - if (inIDE && getter == NoSymbol) return NoSymbol; - val result = getter.owner.newValue(getter.pos, getter.name) - .setInfo(getter.tpe.resultType) - .setFlag(DEFERRED) - if (getter.setter(member.owner) != NoSymbol) result.setFlag(MUTABLE) - result - } else member.accessed - } else member - - /** An explanatory note to be added to error messages - * when there's a problem with abstract var defs */ - def varNotice(sym: Symbol): String = - if (underlying(sym).isVariable) - "\n(Note that variables need to be initialized to be defined)" - else "" -} - -- cgit v1.2.3