Uniformise optimiSation spelling

The flag is called -optimise, lets use that eveywhere :)

Author: OlivierBlanvillain

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

@@ -242,16 +242,16 @@ class GenBCodePipeline(val entryPoints: List[Symbol], val int: DottyBackendInter
     } // end of class BCodePhase.Worker1
 
     /*
-     *  Pipeline that takes ClassNodes from queue-2. The unit of work depends on the optimization level:
+     *  Pipeline that takes ClassNodes from queue-2. The unit of work depends on the optimisation level:
      *
-     *    (a) no optimization involves:
+     *    (a) no optimisation involves:
      *          - converting the plain ClassNode to byte array and placing it on queue-3
      */
     class Worker2 {
       // lazy val localOpt = new LocalOpt(new Settings())
 
-      def localOptimizations(classNode: ClassNode): Unit = {
-        // BackendStats.timed(BackendStats.methodOptTimer)(localOpt.methodOptimizations(classNode))
+      def localOptimisations(classNode: ClassNode): Unit = {
+        // BackendStats.timed(BackendStats.methodOptTimer)(localOpt.methodOptimisations(classNode))
       }
 
       def run(): Unit = {
@@ -263,7 +263,7 @@ class GenBCodePipeline(val entryPoints: List[Symbol], val int: DottyBackendInter
           }
           else {
             try {
-              localOptimizations(item.plain)
+              localOptimisations(item.plain)
               addToQ3(item)
             } catch {
               case ex: Throwable =>
@@ -308,7 +308,7 @@ class GenBCodePipeline(val entryPoints: List[Symbol], val int: DottyBackendInter
      *    (a) set-up steps (most notably supporting maps in `BCodeTypes`,
      *        but also "the" writer where class files in byte-array form go)
      *
-     *    (b) building of ASM ClassNodes, their optimization and serialization.
+     *    (b) building of ASM ClassNodes, their optimisation and serialization.
      *
      *    (c) tear down (closing the classfile-writer and clearing maps)
      *

compiler/src/dotty/tools/dotc/Compiler.scala

@@ -76,13 +76,13 @@ class Compiler {
            new ElimByName,          // Expand by-name parameter references
            new AugmentScala2Traits, // Expand traits defined in Scala 2.11 to simulate old-style rewritings
            new ResolveSuper,        // Implement super accessors and add forwarders to trait methods
-           new Simplify,            // Perform local optimizations, simplified versions of what linker does.
+           new Simplify,            // Perform local optimisations, simplified versions of what linker does.
            new PrimitiveForwarders, // Add forwarders to trait methods that have a mismatch between generic and primitives
            new FunctionXXLForwarders, // Add forwarders for FunctionXXL apply method
            new ArrayConstructors),  // Intercept creation of (non-generic) arrays and intrinsify.
       List(new Erasure),            // Rewrite types to JVM model, erasing all type parameters, abstract types and refinements.
       List(new ElimErasedValueType, // Expand erased value types to their underlying implmementation types
-           new VCElideAllocations,  // Peep-hole optimization to eliminate unnecessary value class allocations
+           new VCElideAllocations,  // Peep-hole optimisation to eliminate unnecessary value class allocations
            new Mixin,               // Expand trait fields and trait initializers
            new LazyVals,            // Expand lazy vals
            new Memoize,             // Add private fields to getters and setters
@@ -93,7 +93,7 @@ class Compiler {
                                     // Note: constructors changes decls in transformTemplate, no InfoTransformers should be added after it
            new FunctionalInterfaces, // Rewrites closures to implement @specialized types of Functions.
            new GetClass,            // Rewrites getClass calls on primitive types.
-           new Simplify),           // Perform local optimizations, simplified versions of what linker does.
+           new Simplify),           // Perform local optimisations, simplified versions of what linker does.
       List(new LambdaLift,          // Lifts out nested functions to class scope, storing free variables in environments
                                        // Note: in this mini-phase block scopes are incorrect. No phases that rely on scopes should be here
            new ElimStaticThis,      // Replace `this` references to static objects by global identifiers

compiler/src/dotty/tools/dotc/config/Config.scala

@@ -82,8 +82,8 @@ object Config {
   final val fastPathForRefinedSubtype = true
 
   /** If this flag is set, `TypeOps.normalizeToClassRefs` will insert forwarders
-   *  for type parameters of base classes. This is an optimization, which avoids
-   *  long alias chains. We should  not rely on the optimization, though. So changing
+   *  for type parameters of base classes. This is an optimisation, which avoids
+   *  long alias chains. We should  not rely on the optimisation, though. So changing
    *  the flag to false can be used for checking that everything works OK without it.
    */
   final val forwardTypeParams = true

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

@@ -43,7 +43,7 @@ trait ConstraintHandling {
   protected var homogenizeArgs = false
 
   /** We are currently comparing type lambdas. Used as a flag for
-   *  optimization: when `false`, no need to do an expensive `pruneLambdaParams`
+   *  optimisation: when `false`, no need to do an expensive `pruneLambdaParams`
    */
   protected var comparedTypeLambdas: Set[TypeLambda] = Set.empty
 

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

@@ -1079,7 +1079,7 @@ object Denotations {
   // --------------- PreDenotations -------------------------------------------------
 
   /** A PreDenotation represents a group of single denotations
-   *  It is used as an optimization to avoid forming MultiDenotations too eagerly.
+   *  It is used as an optimisation to avoid forming MultiDenotations too eagerly.
    */
   trait PreDenotation {
 

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

@@ -11,7 +11,7 @@ import dotty.tools.dotc.core.Types.Type
  *    from the method definitions and calls (implemented in branch implement-phantom-types-part-2).
  *  - Definitions of `def`, `val`, `lazy val` and `var` returning a phantom type to return a ErasedPhantom. Where fields
  *    with ErasedPhantom type are not memoized (see transform/Memoize.scala).
- *  - Calls to Phantom.assume become calls to ErasedPhantom.UNIT. Intended to be optimized away by local optimizations.
+ *  - Calls to Phantom.assume become calls to ErasedPhantom.UNIT. Intended to be optimized away by local optimisations.
  */
 object PhantomErasure {
 

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

@@ -2953,7 +2953,7 @@ object Types {
       case tycon: TypeRef =>
         tycon.info match {
           case TypeBounds(lo, hi) =>
-            if (lo eq hi) superType // optimization, can profit from caching in this case
+            if (lo eq hi) superType // optimisation, can profit from caching in this case
             else lo.applyIfParameterized(args)
           case _ => NoType
         }

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

@@ -171,7 +171,7 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {
 
     // 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
-    //   this is a special instance of the advanced inlining optimization that takes a method call on
+    //   this is a special instance of the advanced inlining optimisation 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 {
 
@@ -976,7 +976,7 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {
           if (casesRebindingPropagated nonEmpty) {
             // before optimizing, check casesNoSubstOnly for presence of a default case,
             // since DCE will eliminate trivial cases like `case _ =>`, even if they're the last one
-            // exhaustivity and reachability must be checked before optimization as well
+            // exhaustivity and reachability must be checked before optimisation as well
             // TODO: improve notion of trivial/irrefutable -- a trivial type test before the body still makes for a default case
             //   ("trivial" depends on whether we're emitting a straight match or an exception, or more generally, any supertype of scrutSym.tpe is a no-op)
             //   irrefutability checking should use the approximation framework also used for CSE, unreachability and exhaustivity checking

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

@@ -58,7 +58,7 @@ import TreeTransforms.{MiniPhaseTransform, TransformerInfo}
  *
  *             In scalac, If the method had type parameters, the call must contain same
  *             parameters as type arguments. This is no longer case in dotc.
- *             In scalac, this is named tailCall but it does only provide optimization for
+ *             In scalac, this is named tailCall but it does only provide optimisation for
  *             self recursive functions, that's why it's renamed to tailrec
  *             </p>
  */

compiler/src/dotty/tools/dotc/transform/patmat/Space.scala

@@ -167,7 +167,7 @@ trait SpaceLogic {
         ss.forall(isSubspace(_, b))
       case (Typ(tp1, _), Typ(tp2, _)) =>
         isSubType(tp1, tp2)
-      case (Typ(tp1, _), Or(ss)) =>  // optimization: don't go to subtraction too early
+      case (Typ(tp1, _), Or(ss)) =>  // optimisation: don't go to subtraction too early
         ss.exists(isSubspace(a, _)) || tryDecompose1(tp1)
       case (_, Or(_)) =>
         simplify(minus(a, b)) == Empty

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

@@ -1214,7 +1214,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
   /** Adds inline to final vals with idempotent rhs
    *
    *  duplicating scalac behavior: for final vals that have rhs as constant, we do not create a field
-   *  and instead return the value. This seemingly minor optimization has huge effect on initialization
+   *  and instead return the value. This seemingly minor optimisation has huge effect on initialization
    *  order and the values that can be observed during superconstructor call
    *
    *  see remark about idempotency in PostTyper#normalizeTree

compiler/src/dotty/tools/io/PlainFile.scala

@@ -53,7 +53,7 @@ class PlainFile(val givenPath: Path) extends AbstractFile {
 
   /** Returns all abstract subfiles of this abstract directory. */
   def iterator: Iterator[AbstractFile] = {
-    // Optimization: Assume that the file was not deleted and did not have permissions changed
+    // Optimisation: Assume that the file was not deleted and did not have permissions changed
     // between the call to `list` and the iteration. This saves a call to `exists`.
     def existsFast(path: Path) = path match {
       case (_: Directory | _: io.File) => true

docs/blog/_posts/2016-12-05-implicit-function-types.md

@@ -33,7 +33,7 @@ boilerplate code and increasing applicability.
 **First Step**: My pull request is a first implementation. It solves the
  problem in principle, but introduces some run-time overhead. The
  next step will be to eliminate the run-time overhead through some
- simple optimizations.
+ simple optimisations.
 
 ## Implicit Parameters
 

docs/docs/internals/backend.md

@@ -62,7 +62,7 @@ ready for serialization to disk.
 
 Currently the queue subsystem is all sequential, but as can be seen in
 http://magarciaepfl.github.io/scala/ the above design enables overlapping (a.1)
-building of `ClassNodes`, (a.2) intra-method optimizations, and (a.3)
+building of `ClassNodes`, (a.2) intra-method optimisations, and (a.3)
 serialization to disk.
 
 This subsystem is described in detail in `GenBCode.scala`

docs/docs/internals/overall-structure.md

@@ -126,7 +126,7 @@ phases. The current list of phases is specified in class [Compiler] as follows:
            new ArrayConstructors),  // Intercept creation of (non-generic) arrays and intrinsify.
       List(new Erasure),            // Rewrite types to JVM model, erasing all type parameters, abstract types and refinements.
       List(new ElimErasedValueType, // Expand erased value types to their underlying implementation types
-           new VCElideAllocations,  // Peep-hole optimization to eliminate unnecessary value class allocations
+           new VCElideAllocations,  // Peep-hole optimisation to eliminate unnecessary value class allocations
            new Mixin,               // Expand trait fields and trait initializers
            new LazyVals,            // Expand lazy vals
            new Memoize,             // Add private fields to getters and setters