diff options
Diffstat (limited to 'src/dotty')
23 files changed, 50 insertions, 50 deletions
diff --git a/src/dotty/tools/backend/jvm/CollectEntryPoints.scala b/src/dotty/tools/backend/jvm/CollectEntryPoints.scala index 734890daa..513144bd6 100644 --- a/src/dotty/tools/backend/jvm/CollectEntryPoints.scala +++ b/src/dotty/tools/backend/jvm/CollectEntryPoints.scala @@ -40,7 +40,7 @@ class CollectEntryPoints extends MiniPhaseTransform { def phaseName: String = "Collect entry points" override def transformDefDef(tree: tpd.DefDef)(implicit ctx: Context, info: TransformerInfo): tpd.Tree = { - if((tree.symbol ne NoSymbol) && CollectEntryPoints.isJavaEntyPoint(tree.symbol)) { + if ((tree.symbol ne NoSymbol) && CollectEntryPoints.isJavaEntyPoint(tree.symbol)) { ctx.genBCodePhase.asInstanceOf[GenBCode].registerEntryPoint(tree.symbol) } tree diff --git a/src/dotty/tools/backend/jvm/DottyBackendInterface.scala b/src/dotty/tools/backend/jvm/DottyBackendInterface.scala index ee8d27137..e9c8dbc80 100644 --- a/src/dotty/tools/backend/jvm/DottyBackendInterface.scala +++ b/src/dotty/tools/backend/jvm/DottyBackendInterface.scala @@ -376,7 +376,7 @@ class DottyBackendInterface()(implicit ctx: Context) extends BackendInterface{ def shouldEmitJumpAfterLabels = true def dumpClasses: Option[String] = - if(ctx.settings.Ydumpclasses.isDefault) None + if (ctx.settings.Ydumpclasses.isDefault) None else Some(ctx.settings.Ydumpclasses.value) def mainClass: Option[String] = @@ -423,7 +423,7 @@ class DottyBackendInterface()(implicit ctx: Context) extends BackendInterface{ case TermRef(prefix: ThisType, name) => Some(tpd.This(prefix.cls).select(i.symbol)) case TermRef(NoPrefix, name) => - if(i.symbol is Flags.Method) Some(This(i.symbol.enclosingClass).select(i.symbol)) // workaround #342 todo: remove after fixed + if (i.symbol is Flags.Method) Some(This(i.symbol.enclosingClass).select(i.symbol)) // workaround #342 todo: remove after fixed else None case _ => None } @@ -663,7 +663,7 @@ class DottyBackendInterface()(implicit ctx: Context) extends BackendInterface{ def companionSymbol: Symbol = if (sym is Flags.Module) companionClass else companionModule def moduleClass: Symbol = toDenot(sym).moduleClass def enclosingClassSym: Symbol = { - if(this.isClass) { + if (this.isClass) { val ct = ctx.withPhase(ctx.flattenPhase.prev) toDenot(sym)(ct).owner.enclosingClass(ct) } @@ -792,7 +792,7 @@ class DottyBackendInterface()(implicit ctx: Context) extends BackendInterface{ t.info match { case _ => - if(!t.symbol.isClass) nonClassTypeRefToBType(t.symbol) // See comment on nonClassTypeRefToBType + if (!t.symbol.isClass) nonClassTypeRefToBType(t.symbol) // See comment on nonClassTypeRefToBType else primitiveOrClassToBType(t.symbol) // Common reference to a type such as scala.Int or java.lang.String } case Types.ClassInfo(_, sym, _, _, _) => primitiveOrClassToBType(sym) // We get here, for example, for genLoadModule, which invokes toTypeKind(moduleClassSymbol.info) @@ -942,7 +942,7 @@ class DottyBackendInterface()(implicit ctx: Context) extends BackendInterface{ def _3: Tree = field.rhs override def unapply(s: LabelDef): DottyBackendInterface.this.LabelDef.type = { - if(s.symbol is Flags.Label) this.field = s + if (s.symbol is Flags.Label) this.field = s else this.field = null this } @@ -1021,11 +1021,11 @@ class DottyBackendInterface()(implicit ctx: Context) extends BackendInterface{ def _2 = field.meth def _3 = { val t = field.tpt.tpe.typeSymbol - if(t.exists) t + if (t.exists) t else { val arity = field.meth.tpe.widenDealias.paramTypes.size - _1.size val returnsUnit = field.meth.tpe.widenDealias.resultType.classSymbol == UnitClass - if(returnsUnit) + if (returnsUnit) ctx.requiredClass(("scala.compat.java8.JProcedure" + arity).toTermName) else ctx.requiredClass(("scala.compat.java8.JFunction" + arity).toTermName) } diff --git a/src/dotty/tools/backend/jvm/LabelDefs.scala b/src/dotty/tools/backend/jvm/LabelDefs.scala index 769dcdc36..8f9e3bdcc 100644 --- a/src/dotty/tools/backend/jvm/LabelDefs.scala +++ b/src/dotty/tools/backend/jvm/LabelDefs.scala @@ -44,7 +44,7 @@ import StdNames.nme * * <label> def foo(i: Int) = { * <label> def bar = 0 - * <label> def dough(i: Int) = if(i == 0) bar else foo(i-1) + * <label> def dough(i: Int) = if (i == 0) bar else foo(i-1) * dough(i) * } * @@ -54,7 +54,7 @@ import StdNames.nme * * \ * <label> def foo(i: Int) = dough(i) - * <label> def dough(i: Int) = if(i == 0) bar else foo(i-1) + * <label> def dough(i: Int) = if (i == 0) bar else foo(i-1) * <label> def bar = 2 * foo(100) * @@ -64,7 +64,7 @@ import StdNames.nme * <jump foo> * <label> def foo(i: Int) = dough(i) * // <jump a> // unreachable - * <label> def dough(i: Int) = if(i == 0) bar else foo(i-1) + * <label> def dough(i: Int) = if (i == 0) bar else foo(i-1) * // <jump a> // unreachable * <label> def bar = 2 * // <jump a> // unreachable @@ -107,7 +107,7 @@ class LabelDefs extends MiniPhaseTransform { labelLevel = labelLevel + 1 val r = Block(moveLabels(t), t) labelLevel = labelLevel - 1 - if(labelLevel == 0) beingAppended.clear() + if (labelLevel == 0) beingAppended.clear() r case _ => if (entryPoints.nonEmpty && labelDefs.nonEmpty) super.transform(tree) else tree } @@ -206,14 +206,14 @@ class LabelDefs extends MiniPhaseTransform { labelCalls(r.symbol) = parentLabelCalls parentLabelCalls = st - if(shouldMoveLabel) { + if (shouldMoveLabel) { labelDefs(r.symbol) = r EmptyTree } else r case t: Apply if t.symbol is Flags.Label => val sym = t.symbol parentLabelCalls = parentLabelCalls + t - if(owner != sym) callCounts(sym) = callCounts(sym) + 1 + if (owner != sym) callCounts(sym) = callCounts(sym) + 1 super.transform(tree) case _ => super.transform(tree) diff --git a/src/dotty/tools/dotc/ast/tpd.scala b/src/dotty/tools/dotc/ast/tpd.scala index 20deab372..955439413 100644 --- a/src/dotty/tools/dotc/ast/tpd.scala +++ b/src/dotty/tools/dotc/ast/tpd.scala @@ -776,7 +776,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo { } else args } - val callArgs: List[Tree] = if(args.isEmpty) Nil else { + val callArgs: List[Tree] = if (args.isEmpty) Nil else { val expectedType = selected.widen.paramTypess.head.last val lastParam = args.last adaptLastArg(lastParam, expectedType) diff --git a/src/dotty/tools/dotc/core/Symbols.scala b/src/dotty/tools/dotc/core/Symbols.scala index e573de664..dab84bb5f 100644 --- a/src/dotty/tools/dotc/core/Symbols.scala +++ b/src/dotty/tools/dotc/core/Symbols.scala @@ -162,7 +162,7 @@ trait Symbols { this: Context => privateWithin, coord, assocFile) def synthesizeCompanionMethod(name: Name, target: SymDenotation, owner: SymDenotation)(implicit ctx: Context) = - if(owner.exists && target.exists && !owner.isAbsent && !target.isAbsent) { + if (owner.exists && target.exists && !owner.isAbsent && !target.isAbsent) { val existing = owner.unforcedDecls.lookup(name) existing.orElse{ diff --git a/src/dotty/tools/dotc/core/TypeErasure.scala b/src/dotty/tools/dotc/core/TypeErasure.scala index a45e29287..20cf816c2 100644 --- a/src/dotty/tools/dotc/core/TypeErasure.scala +++ b/src/dotty/tools/dotc/core/TypeErasure.scala @@ -95,7 +95,7 @@ object TypeErasure { def erasure(tp: Type)(implicit ctx: Context): Type = scalaErasureFn(tp)(erasureCtx) def semiErasure(tp: Type)(implicit ctx: Context): Type = semiErasureFn(tp)(erasureCtx) def sigName(tp: Type, isJava: Boolean)(implicit ctx: Context): TypeName = { - val seqClass = if(isJava) defn.ArrayClass else defn.SeqClass + val seqClass = if (isJava) defn.ArrayClass else defn.SeqClass val normTp = if (tp.isRepeatedParam) tp.translateParameterized(defn.RepeatedParamClass, seqClass) else tp diff --git a/src/dotty/tools/dotc/core/Types.scala b/src/dotty/tools/dotc/core/Types.scala index 802a4e406..e6235695e 100644 --- a/src/dotty/tools/dotc/core/Types.scala +++ b/src/dotty/tools/dotc/core/Types.scala @@ -76,7 +76,7 @@ object Types { val uniqId = { nextId = nextId + 1 -// if(nextId == 19555) +// if (nextId == 19555) // println("foo") nextId } diff --git a/src/dotty/tools/dotc/core/pickling/ClassfileParser.scala b/src/dotty/tools/dotc/core/pickling/ClassfileParser.scala index a358fc2b0..478ee0dd7 100644 --- a/src/dotty/tools/dotc/core/pickling/ClassfileParser.scala +++ b/src/dotty/tools/dotc/core/pickling/ClassfileParser.scala @@ -92,7 +92,7 @@ class ClassfileParser( if (c != classRoot.symbol) mismatchError(c) } - if(classRoot.symbol.id == 4812) { + if (classRoot.symbol.id == 4812) { println("bar") } diff --git a/src/dotty/tools/dotc/parsing/JavaParsers.scala b/src/dotty/tools/dotc/parsing/JavaParsers.scala index 4f3d20f45..297f3c0f9 100644 --- a/src/dotty/tools/dotc/parsing/JavaParsers.scala +++ b/src/dotty/tools/dotc/parsing/JavaParsers.scala @@ -121,11 +121,11 @@ object JavaParsers { case nil => (EmptyTree, nil) } var (constr1, stats1) = pullOutFirstConstr(stats) - if(constr1 == EmptyTree) constr1 = makeConstructor(List(), tparams) + if (constr1 == EmptyTree) constr1 = makeConstructor(List(), tparams) // A dummy first constructor is needed for Java classes so that the real constructors see the // import of the companion object. The constructor has parameter of type Unit so no Java code // can call it. - if(needsDummyConstr) { + if (needsDummyConstr) { stats1 = constr1 :: stats1 constr1 = makeConstructor(List(scalaDot(tpnme.Unit)), tparams, Flags.JavaDefined | Flags.PrivateLocal) } @@ -579,9 +579,9 @@ object JavaParsers { def varDecl(pos: Position, mods: Modifiers, tpt: Tree, name: TermName): ValDef = { val tpt1 = optArrayBrackets(tpt) if (in.token == EQUALS && !(mods is Flags.Param)) skipTo(COMMA, SEMI) - val mods1 = if(mods is Flags.Final) mods else mods | Flags.Mutable + val mods1 = if (mods is Flags.Final) mods else mods | Flags.Mutable atPos(pos) { - ValDef(name, tpt1, if(mods is Flags.Param) EmptyTree else unimplementedExpr).withMods(mods1) + ValDef(name, tpt1, if (mods is Flags.Param) EmptyTree else unimplementedExpr).withMods(mods1) } } diff --git a/src/dotty/tools/dotc/parsing/Utility.scala b/src/dotty/tools/dotc/parsing/Utility.scala index 83a61b47e..f522492f8 100644 --- a/src/dotty/tools/dotc/parsing/Utility.scala +++ b/src/dotty/tools/dotc/parsing/Utility.scala @@ -69,7 +69,7 @@ object Utility { else sb append c } - if(!sb.isEmpty) // flush buffer + if (!sb.isEmpty) // flush buffer nb += text(sb.toString()) nb.toList diff --git a/src/dotty/tools/dotc/transform/Erasure.scala b/src/dotty/tools/dotc/transform/Erasure.scala index ab124402a..640d5f13e 100644 --- a/src/dotty/tools/dotc/transform/Erasure.scala +++ b/src/dotty/tools/dotc/transform/Erasure.scala @@ -412,7 +412,7 @@ object Erasure extends TypeTestsCasts{ private def adaptProto(tree: untpd.Tree, pt: Type)(implicit ctx: Context) = { if (pt.isValueType) pt else { - if(tree.typeOpt.derivesFrom(ctx.definitions.UnitClass)) + if (tree.typeOpt.derivesFrom(ctx.definitions.UnitClass)) tree.typeOpt else erasure(tree.typeOpt) } diff --git a/src/dotty/tools/dotc/transform/FullParameterization.scala b/src/dotty/tools/dotc/transform/FullParameterization.scala index 0b6486225..acfeda48e 100644 --- a/src/dotty/tools/dotc/transform/FullParameterization.scala +++ b/src/dotty/tools/dotc/transform/FullParameterization.scala @@ -91,7 +91,7 @@ trait FullParameterization { case info: ExprType => (0, info.resultType) case _ => (0, info) } - val ctparams = if(abstractOverClass) clazz.typeParams else Nil + val ctparams = if (abstractOverClass) clazz.typeParams else Nil val ctnames = ctparams.map(_.name.unexpandedName) /** The method result type */ diff --git a/src/dotty/tools/dotc/transform/LazyVals.scala b/src/dotty/tools/dotc/transform/LazyVals.scala index 87644d2f9..a28102d7b 100644 --- a/src/dotty/tools/dotc/transform/LazyVals.scala +++ b/src/dotty/tools/dotc/transform/LazyVals.scala @@ -27,7 +27,7 @@ class LazyVals extends MiniPhaseTransform with SymTransformer { def transformSym(d: SymDenotation)(implicit ctx: Context): SymDenotation = { - if(d is(Flags.Lazy, butNot = Flags.ModuleVal | Flags.Method)) { + if (d is(Flags.Lazy, butNot = Flags.ModuleVal | Flags.Method)) { // Method flag is set on lazy vals coming from Unpickler. They are already methods and shouldn't be transformed twice d.copySymDenotation( initFlags = d.flags | Flags.Method, @@ -301,7 +301,7 @@ class LazyVals extends MiniPhaseTransform with SymTransformer { info.ord += 1 ord = info.ord % flagsPerLong val id = info.ord / flagsPerLong - if(ord != 0) { // there are unused bits in already existing flag + if (ord != 0) { // there are unused bits in already existing flag offsetSymbol = companion.moduleClass.info.decl((StdNames.nme.LAZY_FIELD_OFFSET + id.toString).toTermName) .suchThat(sym => (sym is Flags.Synthetic) && sym.isTerm) .symbol.asTerm @@ -335,7 +335,7 @@ class LazyVals extends MiniPhaseTransform with SymTransformer { val cas = Select(ref(helperModule), RLazyVals.Names.cas.toTermName) val accessor = mkThreadSafeDef(x.symbol.asTerm, claz, ord, containerSymbol, x.rhs, tpe, offset, getFlag, state, cas, setFlag, wait) - if(flag eq EmptyTree) + if (flag eq EmptyTree) Thicket(List(containerTree, accessor)) else Thicket(List(containerTree, flag, accessor)) } diff --git a/src/dotty/tools/dotc/transform/PatternMatcher.scala b/src/dotty/tools/dotc/transform/PatternMatcher.scala index 3e5402eb4..0a019e1c5 100644 --- a/src/dotty/tools/dotc/transform/PatternMatcher.scala +++ b/src/dotty/tools/dotc/transform/PatternMatcher.scala @@ -179,7 +179,7 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {thisTrans override def codegen: AbsCodegen = optimizedCodegen // when we know we're targetting Option, do some inlining the optimizer won't do - // for example, `o.flatMap(f)` becomes `if(o == None) None else f(o.get)`, similarly for orElse and guard + // for example, `o.flatMap(f)` becomes `if (o == None) None else f(o.get)`, similarly for orElse and guard // this is a special instance of the advanced inlining optimization that takes a method call on // an object of a type that only has two concrete subclasses, and inlines both bodies, guarded by an if to distinguish the two cases object optimizedCodegen extends CommonCodegen { @@ -407,11 +407,11 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {thisTrans val nextBinder: Symbol lazy val introducedRebindings = /* - if(nextBinder ne prevBinder) Rebindings(prevBinder, nextBinder) + if (nextBinder ne prevBinder) Rebindings(prevBinder, nextBinder) else */ NoRebindings def chainBefore(next: Tree)(casegen: Casegen): Tree = - if(prevBinder ne nextBinder) // happens when typeTest is known to succeed + if (prevBinder ne nextBinder) // happens when typeTest is known to succeed /*atPos(pos)(*/casegen.flatMapCond(cond, res, nextBinder, next)//) else casegen.flatMapGuard(cond, next) } @@ -477,7 +477,7 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {thisTrans def refTpeWiden = ref.tpe.widen def bindInfoWiden = bind.info.widen def loc = bind.showFullName - if(!(ref.tpe <:< bind.info.widen)) { + if (!(ref.tpe <:< bind.info.widen)) { ctx.debuglog(s"here ${bind.showFullName} expected: ${bindInfoWiden.show} got: ${refTpeWiden.show}") } val refCasted = ref.ensureConforms(bind.info) @@ -954,7 +954,7 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {thisTrans object WildcardPattern { def unapply(pat: Tree): Boolean = pat match { case Bind(nme.WILDCARD, WildcardPattern()) => true // don't skip when binding an interesting symbol! - case t if(tpd.isWildcardArg(t)) => true + case t if (tpd.isWildcardArg(t)) => true case x: Ident => isVarPattern(x) case Alternative(ps) => ps forall unapply case EmptyTree => true @@ -1424,7 +1424,7 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {thisTrans else genDrop(binder, expectedLength) ) // this error-condition has already been checked by checkStarPatOK: - // if(isSeq) assert(firstIndexingBinder + nbIndexingIndices + (if(lastIsStar) 1 else 0) == totalArity, "(resultInMonad, ts, subPatTypes, subPats)= " +(resultInMonad, ts, subPatTypes, subPats)) + // if (isSeq) assert(firstIndexingBinder + nbIndexingIndices + (if (lastIsStar) 1 else 0) == totalArity, "(resultInMonad, ts, subPatTypes, subPats)= " +(resultInMonad, ts, subPatTypes, subPats)) // [1] there are `firstIndexingBinder` non-seq tuple elements preceding the Seq // [2] then we have to index the binder that represents the sequence for the remaining subpatterns, except for... @@ -1440,7 +1440,7 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {thisTrans // require (nbSubPats > 0 && (!lastIsStar || isSeq)) protected def subPatRefs(binder: Symbol): List[Tree] = { val refs = if (totalArity > 0 && isSeq) subPatRefsSeq(binder) - else if(defn.isProductSubType(binder.info)) productElemsToN(binder, totalArity) + else if (defn.isProductSubType(binder.info)) productElemsToN(binder, totalArity) else ref(binder):: Nil val refsSymbols = refs.map(_.symbol) // just for debugging refs @@ -1551,7 +1551,7 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {thisTrans // the trees that select the subpatterns on the extractor's result, referenced by `binder` // require (totalArity > 0 && (!lastIsStar || isSeq)) protected def subPatRefs(binder: Symbol, subpatBinders: List[Symbol], binderTypeTested: Type): List[Tree] = { - if(aligner.isSingle && aligner.extractor.prodArity == 1 && defn.isTupleType(binder.info)) { + if (aligner.isSingle && aligner.extractor.prodArity == 1 && defn.isTupleType(binder.info)) { // special case for extractor // comparing with scalac additional assertions added val subpw = subpatBinders.head.info.widen @@ -1815,8 +1815,8 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {thisTrans //println(s"${_id}unapplyArgs(${result.widen}") val expanded:List[Type] = /*( if (result =:= defn.BooleanType) Nil - else if(defn.isProductSubType(result)) productSelectorTypes(result) - else if(result.classSymbol is Flags.CaseClass) result.decls.filter(x => x.is(Flags.CaseAccessor) && x.is(Flags.Method)).map(_.info).toList + else if (defn.isProductSubType(result)) productSelectorTypes(result) + else if (result.classSymbol is Flags.CaseClass) result.decls.filter(x => x.is(Flags.CaseAccessor) && x.is(Flags.Method)).map(_.info).toList else result.select(nme.get) :: Nil )*/ if ((extractorMemberType(resultType, nme.isDefined) isRef defn.BooleanClass) && resultOfGet.exists) diff --git a/src/dotty/tools/dotc/transform/SuperAccessors.scala b/src/dotty/tools/dotc/transform/SuperAccessors.scala index 36f0acc83..8857b6921 100644 --- a/src/dotty/tools/dotc/transform/SuperAccessors.scala +++ b/src/dotty/tools/dotc/transform/SuperAccessors.scala @@ -554,7 +554,7 @@ class SuperAccessors extends MacroTransform with IdentityDenotTransformer { this assert(referencingClass.isClass, referencingClass) referencingClass } - else if(referencingClass.owner.enclosingClass.exists) + else if (referencingClass.owner.enclosingClass.exists) hostForAccessorOf(sym, referencingClass.owner.enclosingClass.asClass) else referencingClass diff --git a/src/dotty/tools/dotc/transform/TailRec.scala b/src/dotty/tools/dotc/transform/TailRec.scala index 2fd0c439c..09b4c735b 100644 --- a/src/dotty/tools/dotc/transform/TailRec.scala +++ b/src/dotty/tools/dotc/transform/TailRec.scala @@ -210,7 +210,7 @@ class TailRec extends MiniPhaseTransform with DenotTransformer with FullParamete val reciever = noTailTransform(recv) val callTargs: List[tpd.Tree] = - if(abstractOverClass) { + if (abstractOverClass) { val classTypeArgs = recv.tpe.baseTypeWithArgs(enclosingClass).argInfos targs ::: classTypeArgs.map(x => ref(x.typeSymbol)) } else targs diff --git a/src/dotty/tools/dotc/transform/TraitConstructors.scala b/src/dotty/tools/dotc/transform/TraitConstructors.scala index 8c92f1f7b..a98f52ca4 100644 --- a/src/dotty/tools/dotc/transform/TraitConstructors.scala +++ b/src/dotty/tools/dotc/transform/TraitConstructors.scala @@ -22,7 +22,7 @@ class TraitConstructors extends MiniPhaseTransform with SymTransformer { override def treeTransformPhase: Phase = this.phase def transformSym(sym: SymDenotation)(implicit ctx: Context): SymDenotation = { - if(sym.isPrimaryConstructor && (sym.owner is Flags.Trait)) + if (sym.isPrimaryConstructor && (sym.owner is Flags.Trait)) sym.copySymDenotation(name = nme.INITIALIZER_PREFIX ++ sym.owner.fullName) else sym } diff --git a/src/dotty/tools/dotc/transform/TreeChecker.scala b/src/dotty/tools/dotc/transform/TreeChecker.scala index af5a9a1f2..43e1ce8a6 100644 --- a/src/dotty/tools/dotc/transform/TreeChecker.scala +++ b/src/dotty/tools/dotc/transform/TreeChecker.scala @@ -116,7 +116,7 @@ class TreeChecker extends Phase with SymTransformer { val sym = tree.symbol everDefinedSyms.get(sym) match { case Some(t) => - if(t ne tree) + if (t ne tree) ctx.warning(i"symbol ${sym.fullName} is defined at least twice in different parts of AST") // should become an error case None => @@ -124,7 +124,7 @@ class TreeChecker extends Phase with SymTransformer { } assert(!nowDefinedSyms.contains(sym), i"doubly defined symbol: ${sym.fullName} in $tree") - if(ctx.settings.YcheckMods.value) { + if (ctx.settings.YcheckMods.value) { tree match { case t: MemberDef => if (t.name ne sym.name) ctx.warning(s"symbol ${sym.fullName} name doesn't correspond to AST: ${t}") diff --git a/src/dotty/tools/dotc/transform/TreeTransform.scala b/src/dotty/tools/dotc/transform/TreeTransform.scala index ce3e3ce63..3bd005991 100644 --- a/src/dotty/tools/dotc/transform/TreeTransform.scala +++ b/src/dotty/tools/dotc/transform/TreeTransform.scala @@ -186,7 +186,7 @@ object TreeTransforms { case ref: SymDenotation => val annotTrees = ref.annotations.map(_.tree) val annotTrees1 = annotTrees.mapConserve(annotationTransformer.macroTransform) - val annots1 = if(annotTrees eq annotTrees1) ref.annotations else annotTrees1.map(new ConcreteAnnotation(_)) + val annots1 = if (annotTrees eq annotTrees1) ref.annotations else annotTrees1.map(new ConcreteAnnotation(_)) if ((info1 eq ref.info) && (annots1 eq ref.annotations)) ref else ref.copySymDenotation(info = info1, annotations = annots1) case _ => if (info1 eq ref.info) ref else ref.derivedSingleDenotation(ref.symbol, info1) diff --git a/src/dotty/tools/dotc/typer/FrontEnd.scala b/src/dotty/tools/dotc/typer/FrontEnd.scala index b3cc23ba4..bb313501d 100644 --- a/src/dotty/tools/dotc/typer/FrontEnd.scala +++ b/src/dotty/tools/dotc/typer/FrontEnd.scala @@ -25,7 +25,7 @@ class FrontEnd extends Phase { def parse(implicit ctx: Context) = monitor("parsing") { val unit = ctx.compilationUnit unit.untpdTree = - if(unit.isJava) new JavaParser(unit.source).parse() + if (unit.isJava) new JavaParser(unit.source).parse() else new Parser(unit.source).parse() typr.println("parsed:\n" + unit.untpdTree.show) } diff --git a/src/dotty/tools/dotc/typer/Implicits.scala b/src/dotty/tools/dotc/typer/Implicits.scala index 2c7aaaeb1..cd3b633ac 100644 --- a/src/dotty/tools/dotc/typer/Implicits.scala +++ b/src/dotty/tools/dotc/typer/Implicits.scala @@ -347,7 +347,7 @@ trait ImplicitRunInfo { self: RunInfo => if (liftedTp ne tp) iscope(liftedTp, isLifted = true) else ofTypeImplicits(collectCompanions(tp)) if (ctx.typerState.ephemeral) record("ephemeral cache miss: implicitScope") - else if(cacheResult) implicitScopeCache(tp) = result + else if (cacheResult) implicitScopeCache(tp) = result result } finally ctx.typerState.ephemeral |= savedEphemeral diff --git a/src/dotty/tools/dotc/typer/RefChecks.scala b/src/dotty/tools/dotc/typer/RefChecks.scala index 2783f7f31..9b14fffc0 100644 --- a/src/dotty/tools/dotc/typer/RefChecks.scala +++ b/src/dotty/tools/dotc/typer/RefChecks.scala @@ -1057,7 +1057,7 @@ class RefChecks extends MiniPhase with SymTransformer { thisTransformer => // FIXME: reconcile this check with one in resetAttrs case _ => checkUndesiredProperties(sym, tree.pos) } - if(sym.isJavaDefined) + if (sym.isJavaDefined) sym.typeParams foreach (_.cookJavaRawInfo()) if (!tp.isHigherKinded && !skipBounds) checkBounds(tree, pre, sym.owner, sym.typeParams, args) @@ -1101,7 +1101,7 @@ class RefChecks extends MiniPhase with SymTransformer { thisTransformer => } case tpt@TypeTree() => - if(tpt.original != null) { + if (tpt.original != null) { tpt.original foreach { case dc@TypeTreeWithDeferredRefCheck() => applyRefchecksToAnnotations(dc.check()) // #2416 diff --git a/src/dotty/tools/dotc/typer/Typer.scala b/src/dotty/tools/dotc/typer/Typer.scala index 6befe58df..a2b280c6e 100644 --- a/src/dotty/tools/dotc/typer/Typer.scala +++ b/src/dotty/tools/dotc/typer/Typer.scala @@ -309,7 +309,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit } } - if(ctx.compilationUnit.isJava && tree.name.isTypeName) { + if (ctx.compilationUnit.isJava && tree.name.isTypeName) { // SI-3120 Java uses the same syntax, A.B, to express selection from the // value A and from the type A. We have to try both. tryEither(tryCtx => asSelect(tryCtx))((_,_) => asJavaSelectFromTypeTree(ctx)) |