Remove extra parentheses

Author: OlivierBlanvillain

compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala

@@ -682,7 +682,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
 
     def isFinal: Boolean = sym.is(Flags.Final)
     def isStaticMember: Boolean = (sym ne NoSymbol) &&
-      ((sym.is(Flags.JavaStatic)) || toDenot(sym).hasAnnotation(ctx.definitions.ScalaStaticAnnot))
+      (sym.is(Flags.JavaStatic) || toDenot(sym).hasAnnotation(ctx.definitions.ScalaStaticAnnot))
       // guard against no sumbol cause this code is executed to select which call type(static\dynamic) to use to call array.clone
 
     def isBottomClass: Boolean = (sym ne defn.NullClass) && (sym ne defn.NothingClass)

compiler/src/dotty/tools/dotc/ast/tpd.scala

@@ -285,7 +285,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       if (cls.classInfo.selfInfo ne NoType) ValDef(ctx.newSelfSym(cls))
       else EmptyValDef
     def isOwnTypeParam(stat: Tree) =
-      (stat.symbol.is(TypeParam)) && stat.symbol.owner == cls
+      stat.symbol.is(TypeParam) && stat.symbol.owner == cls
     val bodyTypeParams = body filter isOwnTypeParam map (_.symbol)
     val newTypeParams =
       for (tparam <- cls.typeParams if !(bodyTypeParams contains tparam))

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

@@ -311,7 +311,7 @@ object Denotations {
     def requiredMethod(pname: PreName, argTypes: List[Type])(implicit ctx: Context): TermSymbol = {
       val name = pname.toTermName
       info.member(name).requiredSymbol(i"method", name, this, argTypes) { x =>
-        (x.is(Method)) && {
+        x.is(Method) && {
           x.info.paramInfoss match {
             case paramInfos :: Nil => paramInfos.corresponds(argTypes)(_ =:= _)
             case _ => false
@@ -1340,7 +1340,7 @@ object Denotations {
      *  enter it.
      */
     def missingHook(owner: Symbol, name: Name)(implicit ctx: Context): Symbol =
-      if ((owner.is(Package)) && name.isTermName)
+      if (owner.is(Package) && name.isTermName)
         ctx.newCompletePackageSymbol(owner, name.asTermName).entered
       else
         NoSymbol

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

@@ -1481,7 +1481,7 @@ object SymDenotations {
      */
     private def typeParamsFromDecls(implicit ctx: Context) =
       unforcedDecls.filter(sym =>
-        (sym.is(TypeParam)) && sym.owner == symbol).asInstanceOf[List[TypeSymbol]]
+        sym.is(TypeParam) && sym.owner == symbol).asInstanceOf[List[TypeSymbol]]
 
     /** The type parameters of this class */
     override final def typeParams(implicit ctx: Context): List[TypeSymbol] = {

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

@@ -751,7 +751,7 @@ object Symbols {
 
     /** The source or class file from which this class was generated, null if not applicable. */
     override def associatedFile(implicit ctx: Context): AbstractFile =
-      if (assocFile != null || (this.owner.is(PackageClass)) || this.isEffectiveRoot) assocFile
+      if (assocFile != null || this.owner.is(PackageClass) || this.isEffectiveRoot) assocFile
       else super.associatedFile
 
     private[this] var mySource: SourceFile = NoSource

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

@@ -215,7 +215,7 @@ object TypeErasure {
     }
 
   /** Is `tp` an abstract type or polymorphic type parameter that has `Any`, `AnyVal`,
-   *  or a universal trait as upper bound and that.is(not) Java defined? Arrays of such types are
+   *  or a universal trait as upper bound and that is not Java defined? Arrays of such types are
    *  erased to `Object` instead of `Object[]`.
    */
   def isUnboundedGeneric(tp: Type)(implicit ctx: Context): Boolean = tp.dealias match {

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

@@ -4327,7 +4327,7 @@ object Types {
           case et: ExprType => true
           case _ => false
         }
-        if ((tp.cls.is(Trait)) || zeroParams(tp.cls.primaryConstructor.info)) tp // !!! needs to be adapted once traits have parameters
+        if (tp.cls.is(Trait) || zeroParams(tp.cls.primaryConstructor.info)) tp // !!! needs to be adapted once traits have parameters
         else NoType
       case tp: AppliedType =>
         zeroParamClass(tp.superType)
@@ -5123,7 +5123,7 @@ object Types {
     def apply(pre: Type, name: Name)(implicit ctx: Context): Boolean =
       name.isTypeName && {
         val mbr = pre.nonPrivateMember(name)
-        (mbr.symbol.is(Deferred)) && mbr.info.isInstanceOf[RealTypeBounds]
+        mbr.symbol.is(Deferred) && mbr.info.isInstanceOf[RealTypeBounds]
       }
   }
 

compiler/src/dotty/tools/dotc/parsing/JavaParsers.scala

@@ -738,7 +738,7 @@ object JavaParsers {
         } else {
           if (in.token == ENUM || definesInterface(in.token)) mods |= Flags.JavaStatic
           val decls = memberDecl(start, mods, parentToken, parentTParams)
-          (if ((mods.is(Flags.JavaStatic)) || inInterface && !(decls exists (_.isInstanceOf[DefDef])))
+          (if (mods.is(Flags.JavaStatic) || inInterface && !(decls exists (_.isInstanceOf[DefDef])))
             statics
           else
             members) ++= decls

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

@@ -83,7 +83,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
    *  to the name of the owner.
    */
   protected def hasMeaninglessName(sym: Symbol): Boolean = (
-       (sym.is(Param)) && sym.owner.isSetter    // x$1
+       sym.is(Param) && sym.owner.isSetter    // x$1
     || sym.isClassConstructor                  // this
     || (sym.name == nme.PACKAGE)               // package
   )

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

@@ -27,7 +27,7 @@ abstract class TransformByNameApply extends MiniPhase { thisPhase: DenotTransfor
 
   /** If denotation had an ExprType before, it now gets a function type */
   protected def exprBecomesFunction(symd: SymDenotation)(implicit ctx: Context): Boolean =
-    (symd.is(Param)) || symd.is(ParamAccessor, butNot = Method)
+    symd.is(Param) || symd.is(ParamAccessor, butNot = Method)
 
   protected def isByNameRef(tree: Tree)(implicit ctx: Context): Boolean = {
     val origDenot = originalDenotation(tree)

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

@@ -467,7 +467,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
         }
       }
       val getterPrefix =
-        if ((meth.is(Synthetic)) && meth.name == nme.apply) nme.CONSTRUCTOR else meth.name
+        if (meth.is(Synthetic) && meth.name == nme.apply) nme.CONSTRUCTOR else meth.name
       def getterName = DefaultGetterName(getterPrefix, n)
       if (!meth.hasDefaultParams)
         EmptyTree

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

@@ -301,7 +301,7 @@ class Typer extends Namer
                       curOwner
                   effectiveOwner.thisType.select(name, defDenot)
                 }
-              if (!(curOwner.is(Package)) || isDefinedInCurrentUnit(defDenot))
+              if (!curOwner.is(Package) || isDefinedInCurrentUnit(defDenot))
                 result = checkNewOrShadowed(found, definition) // no need to go further out, we found highest prec entry
               else {
                 if (ctx.scala2Mode && !foundUnderScala2.exists)