remove some unnecessary uses of .nn

Author: olhotak

compiler/src/dotty/tools/dotc/core/OrderingConstraint.scala

@@ -73,7 +73,7 @@ object OrderingConstraint {
           }
           else {
             val prev_es = entries(prev, poly)
-            if (prev_es == null || (es.nn ne prev_es.nn))
+            if (prev_es == null || (es.nn ne prev_es))
               current // can re-use existing entries array.
             else {
               es = es.nn.clone

compiler/src/dotty/tools/dotc/core/SymDenotations.scala

@@ -2581,7 +2581,7 @@ object SymDenotations {
               try f.container == chosen.container catch case NonFatal(ex) => true
             if !ambiguityWarningIssued then
               for conflicting <- assocFiles.find(!sameContainer(_)) do
-                report.warning(em"""${ambiguousFilesMsg(conflicting.nn)}
+                report.warning(em"""${ambiguousFilesMsg(conflicting)}
                                    |Keeping only the definition in $chosen""")
                 ambiguityWarningIssued = true
             multi.filterWithPredicate(_.symbol.associatedFile == chosen)

compiler/src/dotty/tools/dotc/printing/Formatting.scala

@@ -63,7 +63,7 @@ object Formatting {
 
     class ShowImplicits4:
       given [X: Show]: Show[X | Null] with
-        def show(x: X | Null) = if x == null then "null" else CtxShow(toStr(x.nn))
+        def show(x: X | Null) = if x == null then "null" else CtxShow(toStr(x))
 
     class ShowImplicits3 extends ShowImplicits4:
       given Show[Product] = ShowAny

compiler/src/dotty/tools/dotc/transform/Erasure.scala

@@ -695,7 +695,7 @@ object Erasure {
           val owner = sym.maybeOwner
           if defn.specialErasure.contains(owner) then
             assert(sym.isConstructor, s"${sym.showLocated}")
-            defn.specialErasure(owner).nn
+            defn.specialErasure(owner)
           else if defn.isSyntheticFunctionClass(owner) then
             defn.functionTypeErasure(owner).typeSymbol
           else

compiler/src/dotty/tools/dotc/transform/GenericSignatures.scala

@@ -262,7 +262,7 @@ object GenericSignatures {
             typeParamSig(sym.name.lastPart)
           }
           else if (defn.specialErasure.contains(sym))
-            jsig(defn.specialErasure(sym).nn.typeRef)
+            jsig(defn.specialErasure(sym).typeRef)
           else if (sym == defn.UnitClass || sym == defn.BoxedUnitModule)
             jsig(defn.BoxedUnitClass.typeRef)
           else if (sym == defn.NothingClass)

compiler/src/dotty/tools/dotc/transform/LazyVals.scala

@@ -477,12 +477,12 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
         newSymbol(claz, offsetName(info.defs.size), Synthetic, defn.LongType).enteredAfter(this)
       case None =>
         newSymbol(claz, offsetName(0), Synthetic, defn.LongType).enteredAfter(this)
-    offsetSymbol.nn.addAnnotation(Annotation(defn.ScalaStaticAnnot, offsetSymbol.nn.span))
+    offsetSymbol.addAnnotation(Annotation(defn.ScalaStaticAnnot, offsetSymbol.span))
     val fieldTree = thizClass.select(lazyNme.RLazyVals.getDeclaredField).appliedTo(Literal(Constant(containerName.mangledString)))
-    val offsetTree = ValDef(offsetSymbol.nn, getOffset.appliedTo(fieldTree))
+    val offsetTree = ValDef(offsetSymbol, getOffset.appliedTo(fieldTree))
     val offsetInfo = appendOffsetDefs.getOrElseUpdate(claz, new OffsetInfo(Nil))
     offsetInfo.defs = offsetTree :: offsetInfo.defs
-    val offset = ref(offsetSymbol.nn)
+    val offset = ref(offsetSymbol)
 
     val swapOver =
         This(claz)
@@ -617,31 +617,31 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
              .symbol.asTerm
         else { // need to create a new flag
           offsetSymbol = newSymbol(claz, offsetById, Synthetic, defn.LongType).enteredAfter(this)
-          offsetSymbol.nn.addAnnotation(Annotation(defn.ScalaStaticAnnot, offsetSymbol.nn.span))
+          offsetSymbol.addAnnotation(Annotation(defn.ScalaStaticAnnot, offsetSymbol.span))
           val flagName = LazyBitMapName.fresh(id.toString.toTermName)
           val flagSymbol = newSymbol(claz, flagName, containerFlags, defn.LongType).enteredAfter(this)
           flag = ValDef(flagSymbol, Literal(Constant(0L)))
           val fieldTree = thizClass.select(lazyNme.RLazyVals.getDeclaredField).appliedTo(Literal(Constant(flagName.toString)))
-          val offsetTree = ValDef(offsetSymbol.nn, getOffsetStatic.appliedTo(fieldTree))
+          val offsetTree = ValDef(offsetSymbol, getOffsetStatic.appliedTo(fieldTree))
           info.defs = offsetTree :: info.defs
         }
 
       case None =>
         offsetSymbol = newSymbol(claz, offsetName(0), Synthetic, defn.LongType).enteredAfter(this)
-        offsetSymbol.nn.addAnnotation(Annotation(defn.ScalaStaticAnnot, offsetSymbol.nn.span))
+        offsetSymbol.addAnnotation(Annotation(defn.ScalaStaticAnnot, offsetSymbol.span))
         val flagName = LazyBitMapName.fresh("0".toTermName)
         val flagSymbol = newSymbol(claz, flagName, containerFlags, defn.LongType).enteredAfter(this)
         flag = ValDef(flagSymbol, Literal(Constant(0L)))
         val fieldTree = thizClass.select(lazyNme.RLazyVals.getDeclaredField).appliedTo(Literal(Constant(flagName.toString)))
-        val offsetTree = ValDef(offsetSymbol.nn, getOffsetStatic.appliedTo(fieldTree))
+        val offsetTree = ValDef(offsetSymbol, getOffsetStatic.appliedTo(fieldTree))
         appendOffsetDefs += (claz -> new OffsetInfo(List(offsetTree), ord))
     }
 
     val containerName = LazyLocalName.fresh(x.name.asTermName)
     val containerSymbol = newSymbol(claz, containerName, x.symbol.flags &~ containerFlagsMask | containerFlags, tpe, coord = x.symbol.coord).enteredAfter(this)
     val containerTree = ValDef(containerSymbol, defaultValue(tpe))
 
-    val offset =  ref(offsetSymbol.nn)
+    val offset =  ref(offsetSymbol)
     val getFlag = Select(ref(defn.LazyValsModule), lazyNme.RLazyVals.get)
     val setFlag = Select(ref(defn.LazyValsModule), lazyNme.RLazyVals.setFlag)
     val wait =    Select(ref(defn.LazyValsModule), lazyNme.RLazyVals.wait4Notification)

compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala

@@ -466,13 +466,13 @@ object ProtoTypes {
             targ = typerFn(arg)
             // TODO: investigate why flow typing is not working on `targ`
             if ctx.reporter.hasUnreportedErrors then
-              if hasInnerErrors(targ.nn, argType) then
+              if hasInnerErrors(targ, argType) then
                 state.errorArgs += arg
             else
-              state.typedArg = state.typedArg.updated(arg, targ.nn)
+              state.typedArg = state.typedArg.updated(arg, targ)
               state.errorArgs -= arg
         }
-      targ.nn
+      targ
     }
 
     /** The typed arguments. This takes any arguments already typed using