From 2a917f4830fe80987dcea05df74bb5c0a0359833 Mon Sep 17 00:00:00 2001 From: Paul Phillips Date: Mon, 26 Mar 2012 06:40:14 -0700 Subject: Syntactic/organizational optimizations in Settings. --- src/compiler/scala/reflect/internal/Types.scala | 9 +-- src/compiler/scala/reflect/runtime/Settings.scala | 2 +- .../scala/tools/nsc/ast/parser/Parsers.scala | 8 +-- .../scala/tools/nsc/ast/parser/TreeBuilder.scala | 31 ---------- .../scala/tools/nsc/settings/ScalaSettings.scala | 72 +++++++++++++--------- 5 files changed, 49 insertions(+), 73 deletions(-) diff --git a/src/compiler/scala/reflect/internal/Types.scala b/src/compiler/scala/reflect/internal/Types.scala index a20853adc8..3ce8829af6 100644 --- a/src/compiler/scala/reflect/internal/Types.scala +++ b/src/compiler/scala/reflect/internal/Types.scala @@ -448,7 +448,7 @@ trait Types extends api.Types { self: SymbolTable => def resultType(actuals: List[Type]) = this /** Only used for dependent method types. */ - def resultApprox: Type = ApproximateDependentMap(resultType) // if (!settings.YdepMethTpes.value) resultType else + def resultApprox: Type = ApproximateDependentMap(resultType) /** If this is a TypeRef `clazz`[`T`], return the argument `T` * otherwise return this type @@ -2268,7 +2268,7 @@ trait Types extends api.Types { self: SymbolTable => override def isTrivial: Boolean = isTrivial0 && (resultType eq resultType.withoutAnnotations) private lazy val isTrivial0 = resultType.isTrivial && params.forall{p => p.tpe.isTrivial && ( - /*!settings.YdepMethTpes.value ||*/ !(params.exists(_.tpe.contains(p)) || resultType.contains(p))) + !(params.exists(_.tpe.contains(p)) || resultType.contains(p))) } def isImplicit = params.nonEmpty && params.head.isImplicit @@ -2292,8 +2292,9 @@ trait Types extends api.Types { self: SymbolTable => } else existentialAbstraction(params, resultType) - // implicit args can only be depended on in result type: TODO this may be generalised so that the only constraint is dependencies are acyclic - def approximate: MethodType = MethodType(params, resultApprox) // if (!settings.YdepMethTpes.value) this else + // implicit args can only be depended on in result type: + //TODO this may be generalised so that the only constraint is dependencies are acyclic + def approximate: MethodType = MethodType(params, resultApprox) override def finalResultType: Type = resultType.finalResultType diff --git a/src/compiler/scala/reflect/runtime/Settings.scala b/src/compiler/scala/reflect/runtime/Settings.scala index b4f0123114..8b475da0d3 100644 --- a/src/compiler/scala/reflect/runtime/Settings.scala +++ b/src/compiler/scala/reflect/runtime/Settings.scala @@ -23,7 +23,6 @@ class Settings extends internal.settings.MutableSettings { val overrideObjects = new BooleanSetting(false) val debug = new BooleanSetting(false) - // val YdepMethTpes = new BooleanSetting(true) val Ynotnull = new BooleanSetting(false) val explaintypes = new BooleanSetting(false) val verbose = new BooleanSetting(false) @@ -34,4 +33,5 @@ class Settings extends internal.settings.MutableSettings { val Yrecursion = new IntSetting(0) val maxClassfileName = new IntSetting(255) val Xexperimental = new BooleanSetting(false) + val deepCloning = new BooleanSetting (false) } diff --git a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala index ccebcfa54d..45325b4694 100644 --- a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala +++ b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala @@ -1394,13 +1394,7 @@ self => } } } else if (in.token == MATCH) { - t = atPos(t.pos.startOrPoint, in.skipToken()) { - /** For debugging pattern matcher transition issues */ - if (settings.Ypmatnaive.value) - makeSequencedMatch(stripParens(t), inBracesOrNil(caseClauses())) - else - Match(stripParens(t), inBracesOrNil(caseClauses())) - } + t = atPos(t.pos.startOrPoint, in.skipToken())(Match(stripParens(t), inBracesOrNil(caseClauses()))) } // in order to allow anonymous functions as statements (as opposed to expressions) inside // templates, we have to disambiguate them from self type declarations - bug #1565 diff --git a/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala b/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala index 0bc88d1efd..3a6e26d3b5 100644 --- a/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala +++ b/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala @@ -505,37 +505,6 @@ abstract class TreeBuilder { def makePatDef(pat: Tree, rhs: Tree): List[Tree] = makePatDef(Modifiers(0), pat, rhs) - /** For debugging only. Desugar a match statement like so: - * val x = scrutinee - * x match { - * case case1 => ... - * case _ => x match { - * case case2 => ... - * case _ => x match ... - * } - * } - * - * This way there are never transitions between nontrivial casedefs. - * Of course many things break: exhaustiveness and unreachable checking - * do not work, no switches will be generated, etc. - */ - def makeSequencedMatch(selector: Tree, cases: List[CaseDef]): Tree = { - require(cases.nonEmpty) - - val selectorName = freshTermName() - val valdef = atPos(selector.pos)(ValDef(Modifiers(PrivateLocal | SYNTHETIC), selectorName, TypeTree(), selector)) - val nselector = Ident(selectorName) - - def loop(cds: List[CaseDef]): Match = { - def mkNext = CaseDef(Ident(nme.WILDCARD), EmptyTree, loop(cds.tail)) - - if (cds.size == 1) Match(nselector, cds) - else Match(selector, List(cds.head, mkNext)) - } - - Block(List(valdef), loop(cases)) - } - /** Create tree for pattern definition */ def makePatDef(mods: Modifiers, pat: Tree, rhs: Tree): List[Tree] = matchVarPattern(pat) match { case Some((name, tpt)) => diff --git a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala index d1224fc79d..fdde8f9990 100644 --- a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala +++ b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala @@ -30,6 +30,22 @@ trait ScalaSettings extends AbsScalaSettings */ protected def defaultClasspath = sys.env.getOrElse("CLASSPATH", ".") + /** Enabled under -Xexperimental. */ + protected def experimentalSettings = List[BooleanSetting](YmethodInfer, overrideObjects) + + /** Enabled under -Xfuture. */ + protected def futureSettings = List[BooleanSetting]() + + /** Enabled under -optimise. */ + protected def optimiseSettings = List[BooleanSetting](inline, inlineHandlers, Xcloselim, Xdce) + + /** Internal use - syntax enhancements. */ + private class EnableSettings[T <: Setting](val s: T) { + def enabling(toEnable: List[BooleanSetting]): s.type = s withPostSetHook (_ => toEnable foreach (_.value = true)) + def andThen(f: s.T => Unit): s.type = s withPostSetHook (setting => f(setting.value)) + } + private implicit def installEnableSettings[T <: Setting](s: T) = new EnableSettings(s) + /** Disable a setting */ def disable(s: Setting) = allSettings -= s @@ -43,12 +59,8 @@ trait ScalaSettings extends AbsScalaSettings */ // argfiles is only for the help message val argfiles = BooleanSetting ("@", "A text file containing compiler arguments (options and source files)") - val classpath = PathSetting ("-classpath", "Specify where to find user class files.", defaultClasspath) . - withAbbreviation ("-cp") + val classpath = PathSetting ("-classpath", "Specify where to find user class files.", defaultClasspath) withAbbreviation "-cp" val d = OutputSetting (outputDirs, ".") - val optimise = BooleanSetting ("-optimise", "Generates faster bytecode by applying optimisations to the program") . - withAbbreviation("-optimize") . - withPostSetHook(set => List(inline, inlineHandlers, Xcloselim, Xdce) foreach (_.value = set.value)) val nospecialization = BooleanSetting ("-no-specialization", "Ignore @specialize annotations.") /** @@ -64,7 +76,6 @@ trait ScalaSettings extends AbsScalaSettings val elidebelow = IntSetting ("-Xelide-below", "Calls to @elidable methods are omitted if method priority is lower than argument", elidable.MINIMUM, None, elidable.byName get _) val noForwarders = BooleanSetting ("-Xno-forwarders", "Do not generate static forwarders in mirror classes.") - val future = BooleanSetting ("-Xfuture", "Turn on future language features.") val genPhaseGraph = StringSetting ("-Xgenerate-phase-graph", "file", "Generate the phase graphs (outputs .dot files) to fileX.dot.", "") val XlogImplicits = BooleanSetting ("-Xlog-implicits", "Show more detail on why some implicits are not applicable.") val logImplicitConv = BooleanSetting ("-Xlog-implicit-conversions", "Print a message whenever an implicit conversion is inserted.") @@ -92,12 +103,6 @@ trait ScalaSettings extends AbsScalaSettings val showPhases = BooleanSetting ("-Xshow-phases", "Print a synopsis of compiler phases.") val sourceReader = StringSetting ("-Xsource-reader", "classname", "Specify a custom method for reading source files.", "") - // Experimental Extensions - val Xexperimental = BooleanSetting ("-Xexperimental", "Enable experimental extensions.") . - withPostSetHook(set => List(YmethodInfer, overrideObjects) foreach (_.value = set.value)) - // YdepMethTpes, YvirtClasses, - val Xmacros = BooleanSetting ("-Xmacros", "Enable macros.") - /** Compatibility stubs for options whose value name did * not previously match the option name. */ @@ -145,8 +150,7 @@ trait ScalaSettings extends AbsScalaSettings val Ygenjavap = StringSetting ("-Ygen-javap", "dir", "Generate a parallel output directory of .javap files.", "") val Ydumpclasses = StringSetting ("-Ydump-classes", "dir", "Dump the generated bytecode to .class files (useful for reflective compilation that utilizes in-memory classloaders).", "") val Ynosqueeze = BooleanSetting ("-Yno-squeeze", "Disable creation of compact code in matching.") - val Ystatistics = BooleanSetting ("-Ystatistics", "Print compiler statistics.") . - withPostSetHook(set => util.Statistics.enabled = set.value) + val Ystatistics = BooleanSetting ("-Ystatistics", "Print compiler statistics.") andThen (util.Statistics.enabled = _) val stopAfter = PhasesSetting ("-Ystop-after", "Stop after") withAbbreviation ("-stop") // backward compat val stopBefore = PhasesSetting ("-Ystop-before", "Stop before") val refinementMethodDispatch = @@ -157,26 +161,11 @@ trait ScalaSettings extends AbsScalaSettings val YrichExes = BooleanSetting ("-Yrich-exceptions", "Fancier exceptions. Set source search path with -D" + sys.SystemProperties.traceSourcePath.key) - val Yidedebug = BooleanSetting ("-Yide-debug", "Generate, validate and output trees using the interactive compiler.") - val Ybuilderdebug = ChoiceSetting ("-Ybuilder-debug", "manager", "Compile using the specified build manager.", List("none", "refined", "simple"), "none") - val Ybuildmanagerdebug = - BooleanSetting ("-Ybuild-manager-debug", "Generate debug information for the Refined Build Manager compiler.") - val Ytyperdebug = BooleanSetting ("-Ytyper-debug", "Trace all type assignments.") - val Yposdebug = BooleanSetting ("-Ypos-debug", "Trace position validation.") - val Yinferdebug = BooleanSetting ("-Yinfer-debug", "Trace type inference and implicit search.") - val Ypmatdebug = BooleanSetting ("-Ypmat-debug", "Trace all pattern matcher activity.") + val Ybuilderdebug = ChoiceSetting("-Ybuilder-debug", "manager", "Compile using the specified build manager.", List("none", "refined", "simple"), "none") val Yreifycopypaste = BooleanSetting ("-Yreify-copypaste", "Dump the reified trees in copypasteable representation.") - val Yreifydebug = BooleanSetting ("-Yreify-debug", "Trace reification.") - val Ymacrodebug = BooleanSetting ("-Ymacro-debug", "Trace macro-related activities: generation of synthetics, expansion, exceptions.") val Yreplsync = BooleanSetting ("-Yrepl-sync", "Do not use asynchronous code for repl startup") - val Yrepldebug = BooleanSetting ("-Yrepl-debug", "Trace all repl activity.") . - withPostSetHook(_ => interpreter.replProps.debug setValue true) - val Ycompletion = BooleanSetting ("-Ycompletion-debug", "Trace all tab completion activity.") - val Ydocdebug = BooleanSetting ("-Ydoc-debug", "Trace all scaladoc activity.") - val Ypmatnaive = BooleanSetting ("-Ypmat-naive", "Desugar matches as naively as possible.") val Ynotnull = BooleanSetting ("-Ynotnull", "Enable (experimental and incomplete) scala.NotNull.") - // val YdepMethTpes = BooleanSetting ("-Ydependent-method-types", "Allow dependent method types.") val YmethodInfer = BooleanSetting ("-Yinfer-argument-types", "Infer types for arguments of overriden methods.") val etaExpandKeepsStar = BooleanSetting("-Yeta-expand-keeps-star", "Eta-expand varargs methods to T* rather than Seq[T]. This is a temporary option to ease transition.") val noSelfCheck = BooleanSetting ("-Yno-self-type-checks", "Suppress check for self-type conformance among inherited members.") @@ -188,6 +177,29 @@ trait ScalaSettings extends AbsScalaSettings def stop = stopAfter + /** Area-specific debug output. + */ + val Ybuildmanagerdebug = BooleanSetting("-Ybuild-manager-debug", "Generate debug information for the Refined Build Manager compiler.") + val Ycompletion = BooleanSetting("-Ycompletion-debug", "Trace all tab completion activity.") + val Ydocdebug = BooleanSetting("-Ydoc-debug", "Trace all scaladoc activity.") + val Yidedebug = BooleanSetting("-Yide-debug", "Generate, validate and output trees using the interactive compiler.") + val Yinferdebug = BooleanSetting("-Yinfer-debug", "Trace type inference and implicit search.") + val Ymacrodebug = BooleanSetting("-Ymacro-debug", "Trace macro-related activities: generation of synthetics, expansion, exceptions.") + val Ypmatdebug = BooleanSetting("-Ypmat-debug", "Trace all pattern matcher activity.") + val Yposdebug = BooleanSetting("-Ypos-debug", "Trace position validation.") + val Yreifydebug = BooleanSetting("-Yreify-debug", "Trace reification.") + val Yrepldebug = BooleanSetting("-Yrepl-debug", "Trace all repl activity.") andThen (interpreter.replProps.debug setValue _) + val Ytyperdebug = BooleanSetting("-Ytyper-debug", "Trace all type assignments.") + + /** Groups of Settings. + */ + val future = BooleanSetting ("-Xfuture", "Turn on future language features.") enabling futureSettings + val optimise = BooleanSetting ("-optimise", "Generates faster bytecode by applying optimisations to the program") withAbbreviation "-optimize" enabling optimiseSettings + val Xexperimental = BooleanSetting ("-Xexperimental", "Enable experimental extensions.") enabling experimentalSettings + + // Feature extensions + val Xmacros = BooleanSetting ("-Xmacros", "Enable macros.") + /** * IDE-specific settings */ -- cgit v1.2.3