GreatSyntacticShift: 'namespace' -> 'package'

compiler/frontend/src/jet/Library.jet

-namespace jet
+package jet
 
-namespace typeinfo {
+package typeinfo {
     class TypeInfo<out T> {
       fun isSubtypeOf(other : TypeInfo<*>) : Boolean
       fun isInstance(obj : Any?) : Boolean
@@ -10,7 +10,7 @@ namespace typeinfo {
     fun typeinfo<T>(expression : T) : TypeInfo<T>
 }
 
-namespace io {
+package io {
   fun print(message : Any?)
   fun print(message : Int)
   fun print(message : Long)

compiler/frontend/src/org/jetbrains/jet/lexer/Jet.flex

@@ -161,7 +161,6 @@ LONG_TEMPLATE_ENTRY_END=\}
 // TODO: Decide what to do with """ ... """"
 {RAW_STRING_LITERAL} { return JetTokens.RAW_STRING_LITERAL; }
 
-"namespace"  { return JetTokens.NAMESPACE_KEYWORD ;}
 "continue"   { return JetTokens.CONTINUE_KEYWORD ;}
 "package"    { return JetTokens.NAMESPACE_KEYWORD ;}
 "return"     { return JetTokens.RETURN_KEYWORD ;}

compiler/testData/codegen/regressions/kt857.jet

-namespace container_test
+package container_test
 
 class Container<T>(var t : T) {
     fun getT() : T = t

compiler/testData/compiler/smoke/Smoke.kt

-namespace Smoke
+package Smoke
 
 import std.io.*
 

compiler/testData/diagnostics/tests/NamespaceAsExpression.jet

@@ -5,4 +5,4 @@ package a {
 }
 
 val x = <!EXPRESSION_EXPECTED_NAMESPACE_FOUND!>a<!>
-val y2 = <!NAMESPACE_IS_NOT_AN_EXPRESSION!>namespace<!>
+val y2 = <!NAMESPACE_IS_NOT_AN_EXPRESSION!>package<!>

compiler/testData/diagnostics/tests/ShiftFunctionTypes.jet

 class A {
 }
 
-namespace n {
+package n {
   class B
 }
 abstract class XXX() {
     abstract val a : Int
-    abstract val a1 : namespace.<!UNRESOLVED_REFERENCE!>Int<!>
+    abstract val a1 : package.<!UNRESOLVED_REFERENCE!>Int<!>
     abstract val a2 : n.B
     abstract val a3 : (A)
     abstract val a31 : (n.B)

compiler/testData/diagnostics/tests/scopes/Imports.jet

 //FILE:a.kt
-namespace a
+package a
 
 import b.B        //class
 import b.foo      //function
@@ -14,7 +14,7 @@ fun test(arg: B) {
 }
 
 //FILE:b.kt
-namespace b
+package b
 
 class B() {}
 

compiler/testData/psi/Imports.jet

 package foo.bar.goo
 
-import namespace.foo
+import package.foo
 import foo
 import foo.bar
 import foo as bar

compiler/testData/psi/Imports.txt

@@ -14,7 +14,7 @@ JetFile: Imports.jet
     IMPORT_DIRECTIVE
       PsiElement(import)('import')
       PsiWhiteSpace(' ')
-      PsiElement(namespace)('namespace')
+      PsiElement(namespace)('package')
       PsiElement(DOT)('.')
       REFERENCE_EXPRESSION
         PsiElement(IDENTIFIER)('foo')

compiler/testData/psi/Imports_ERR.jet

 package foo.bar.goo
 
-import namespace ;
-import namespace.*
-import namespace. ;
+import package ;
+import package.*
+import package. ;
 
 import foo as
 import foo.

compiler/testData/psi/Imports_ERR.txt

@@ -14,7 +14,7 @@ JetFile: Imports_ERR.jet
     IMPORT_DIRECTIVE
       PsiElement(import)('import')
       PsiWhiteSpace(' ')
-      PsiElement(namespace)('namespace')
+      PsiElement(namespace)('package')
       PsiErrorElement:Expecting '.'
         <empty list>
       PsiWhiteSpace(' ')
@@ -26,7 +26,7 @@ JetFile: Imports_ERR.jet
     IMPORT_DIRECTIVE
       PsiElement(import)('import')
       PsiWhiteSpace(' ')
-      PsiElement(namespace)('namespace')
+      PsiElement(namespace)('package')
       PsiElement(DOT)('.')
       REFERENCE_EXPRESSION
         PsiErrorElement:Expecting qualified name
@@ -37,7 +37,7 @@ JetFile: Imports_ERR.jet
     IMPORT_DIRECTIVE
       PsiElement(import)('import')
       PsiWhiteSpace(' ')
-      PsiElement(namespace)('namespace')
+      PsiElement(namespace)('package')
       PsiElement(DOT)('.')
       PsiWhiteSpace(' ')
       REFERENCE_EXPRESSION

compiler/testData/psi/RootNamespace.jet

@@ -4,10 +4,10 @@ class X
 
 package foo.bar {
   fun foo() {
-    namespace.foo.bar.X
-    namespace.foo.bar.X()
+    package.foo.bar.X
+    package.foo.bar.X()
     when (e) {
-      is namespace.foo.bar.X  #(x) -> {}
+      is package.foo.bar.X  #(x) -> {}
     }
   }
 }
\ No newline at end of file

compiler/testData/psi/RootNamespace.txt

@@ -43,7 +43,7 @@ JetFile: RootNamespace.jet
               DOT_QUALIFIED_EXPRESSION
                 DOT_QUALIFIED_EXPRESSION
                   ROOT_NAMESPACE
-                    PsiElement(namespace)('namespace')
+                    PsiElement(namespace)('package')
                   PsiElement(DOT)('.')
                   REFERENCE_EXPRESSION
                     PsiElement(IDENTIFIER)('foo')
@@ -58,7 +58,7 @@ JetFile: RootNamespace.jet
               DOT_QUALIFIED_EXPRESSION
                 DOT_QUALIFIED_EXPRESSION
                   ROOT_NAMESPACE
-                    PsiElement(namespace)('namespace')
+                    PsiElement(namespace)('package')
                   PsiElement(DOT)('.')
                   REFERENCE_EXPRESSION
                     PsiElement(IDENTIFIER)('foo')
@@ -92,7 +92,7 @@ JetFile: RootNamespace.jet
                       DOT_QUALIFIED_EXPRESSION
                         DOT_QUALIFIED_EXPRESSION
                           ROOT_NAMESPACE
-                            PsiElement(namespace)('namespace')
+                            PsiElement(namespace)('package')
                           PsiElement(DOT)('.')
                           REFERENCE_EXPRESSION
                             PsiElement(IDENTIFIER)('foo')

compiler/testData/psi/When.jet

@@ -45,7 +45,7 @@ fun foo() {
     is a  #(a, b) -> c
     is a.a  #(a, b) -> c
     is a.a  #(foo = a, bar = b) -> c
-    is namespace.a.a  #(a, b) -> c
+    is package.a.a  #(a, b) -> c
     is a  #(val a is T, b) -> c
     is a  #(b, 1) -> c
     in 1..2 -> dsf

compiler/testData/psi/When.txt

@@ -599,7 +599,7 @@ JetFile: When.jet
                 DOT_QUALIFIED_EXPRESSION
                   DOT_QUALIFIED_EXPRESSION
                     ROOT_NAMESPACE
-                      PsiElement(namespace)('namespace')
+                      PsiElement(namespace)('package')
                     PsiElement(DOT)('.')
                     REFERENCE_EXPRESSION
                       PsiElement(IDENTIFIER)('a')

compiler/testData/psi/greatSyntacticShift/functionTypes.jet

 class A {
 }
 
-namespace n {
+package n {
   class B
 }
 abstract class XXX() {

compiler/testData/readClass/class/Class.kt

-namespace test
+package test
 
 class Ramification

compiler/testData/readClass/class/ClassInParam.kt

-namespace test
+package test
 
 class Wine<in T>

compiler/testData/readClass/class/ClassOutParam.kt

-namespace test
+package test
 
 class Juice<in T>

compiler/testData/readClass/class/ClassParam.kt

-namespace test
+package test
 
 class Beer<T>

compiler/testData/readClass/class/ClassParamUpperClassBound.kt

-namespace test
+package test
 
 class Clock<A : java.lang.Number>

compiler/testData/readClass/class/ClassParamUpperClassInterfaceBound.kt

-namespace test
+package test
 
 class Clock<A> where A : java.lang.Number, A : java.lang.CharSequence

compiler/testData/readClass/class/ClassParamUpperInterfaceBound.kt

-namespace test
+package test
 
 class Clock<A : java.lang.CharSequence>

compiler/testData/readClass/class/ClassParamUpperInterfaceClassBound.kt

-namespace test
+package test
 
 class Clock<A> where A : java.lang.CharSequence, A : java.lang.Number

compiler/testData/readClass/class/Trait.kt

-namespace test
+package test
 
 trait Trtrtr

compiler/testData/readClass/fun/ClassFun.kt

-namespace test
+package test
 
 class River {
     fun song() = 1

compiler/testData/readClass/fun/ExtFun.kt

-namespace test
+package test
 
 fun Int.shuffle() = 1

compiler/testData/readClass/fun/ExtFunInClass.kt

-namespace test
+package test
 
 class ExtFunInClass {
     fun Int.shuffle() = 1

compiler/testData/readClass/fun/FunClassParamNotNull.kt

-namespace test
+package test
 
 import java.util.List
 import java.lang.CharSequence

compiler/testData/readClass/fun/FunClassParamNullable.kt

-namespace test
+package test
 
 import java.util.List
 import java.lang.CharSequence

compiler/testData/readClass/fun/FunDefaultArg.kt

-namespace test
+package test
 
 fun funDefaultArg(p: Int, q: Int = 17, r: Int = 18) = 19

compiler/testData/readClass/fun/FunGenericParam.kt

-namespace test
+package test
 
 fun <T> f() = 1

compiler/testData/readClass/fun/FunInParam.kt

-namespace test
+package test
 
 fun <in T> f() = 1

compiler/testData/readClass/fun/FunOutParam.kt

-namespace test
+package test
 
 fun <out T> f() = 1

compiler/testData/readClass/fun/FunParamNotNull.kt

-namespace test
+package test
 
 fun fff(a: java.lang.CharSequence) = 1

compiler/testData/readClass/fun/FunParamNullable.kt

-namespace test
+package test
 
 fun fff(a: java.lang.CharSequence?) = 1

compiler/testData/readClass/fun/FunParamUpperClassBound.kt

-namespace test
+package test
 
 fun <A : java.lang.Number> uno() = 1

compiler/testData/readClass/fun/FunParamUpperClassInterfaceBound.kt

-namespace test
+package test
 
 fun <A> tres() where A : java.lang.Number, A : java.lang.CharSequence = 1

compiler/testData/readClass/fun/FunParamUpperInterfaceBound.kt

-namespace test
+package test
 
 fun <A : java.lang.CharSequence> dos() = 1

compiler/testData/readClass/fun/FunParamUpperInterfaceClassBound.kt

-namespace test
+package test
 
 fun <A> cuatro() where A : java.lang.CharSequence, A : java.lang.Number = 1

compiler/testData/readClass/fun/FunVarargCharSequence.kt

-namespace test
+package test
 
 fun varargCharSequence(a: Int, vararg b: java.lang.CharSequence) = 1

compiler/testData/readClass/fun/FunVarargInt.kt

-namespace test
+package test
 
 fun varargInt(a: Int, vararg b: Int) = 1

compiler/testData/readClass/fun/ModifierAbstract.kt

-namespace test
+package test
 
 abstract class ModifierAbstract {
     abstract fun abs(): Int

compiler/testData/readClass/fun/ModifierOpen.kt

-namespace test
+package test
 
 open class ModifierOpen {
     open fun abs() = 1

compiler/testData/readClass/fun/NsFun.kt

-namespace test
+package test
 
 fun f() = 1

compiler/testData/readClass/fun/ReturnTypeClassParamNotNull.kt

-namespace test
+package test
 
 import java.util.List
 import java.util.ArrayList

compiler/testData/readClass/fun/ReturnTypeClassParamNullable.kt

-namespace test
+package test
 
 import java.util.List
 import java.util.ArrayList

compiler/testData/readClass/fun/ReturnTypeNotNull.kt

-namespace test
+package test
 
 fun ff(): java.lang.CharSequence = throw Exception()

compiler/testData/readClass/fun/ReturnTypeNullable.kt

-namespace test
+package test
 
 fun ff(): java.lang.CharSequence? = null

compiler/testData/resolve/ClassObjects.jet

-namespace Jet86
+package Jet86
 
 ~A~class A {
   class object {

compiler/testData/resolve/Classifiers.jet

-namespace qualified_this {
+package qualified_this {
     ~qtA~class A(val a:Int) {
 
       ~qtB~class B() {

compiler/testData/resolve/LocalObjects.jet

-namespace localObjects {
+package localObjects {
   object ~A~A {
     ~x~val x : Int
   }

compiler/testData/resolve/Namespaces.jet

-namespace root
+package root
 
-~a~namespace a {
+~a~package a {
     import java.*
 
     ~a.a~val a : util.List<Int>? = null
@@ -9,7 +9,7 @@ namespace root
 
 }
 
-namespace a {
+package a {
     import java.util.*
 
     ~a.b~val b : List<Int>? = null

compiler/testData/resolve/NestedObjects.jet

-~ns~namespace nestedObjects {
+~ns~package nestedObjects {
   object ~A~A {
     val b = `A.B`B
     val d = `A`A.`A.B`B.`A.B.A`A

compiler/testData/resolve/Objects.jet

-namespace toplevelObjectDeclarations {
+package toplevelObjectDeclarations {
   class Foo(y : Int) {
     ~foo()~open fun foo() : Int = 1
   }

compiler/testData/resolve/PrimaryConstructors.jet

@@ -11,7 +11,7 @@ fun test() {
     a.`f`f()`:std::Int`
 }
 
-namespace Jet65 {
+package Jet65 {
 
   class Foo(~bar~var bar : Int, ~barr~barr : Int, ~barrr~val barrr : Int) {
     {

examples/src/Bottles.kt

-namespace bottles;
+package bottles;
 
 fun main(args: Array<String>) {
     var bottles: Int = 99;

examples/src/Generics.jet

-namespace generics;
+package generics;
 
 import java.util.*
 

examples/src/HelloNames.kt

-namespace HelloNames
+package HelloNames
 
 fun main(args : Array<String>) {
     var names = ""

examples/src/HelloNamesFaster.kt

-namespace HelloNamesFaster
+package HelloNamesFaster
 
 fun main(args : Array<String>) {
     var names = StringBuilder()

examples/src/HelloNamesRealistic.kt

-namespace HelloNamesRealistic
+package HelloNamesRealistic
 
 fun main(args : Array<String>) {
     val names = args.join(", ")

examples/src/JavaInterop.jet

-namespace JavaInterop
+package JavaInterop
 
 import java.util.*
 

examples/src/NullSafety.jet

-namespace NullSafety
+package NullSafety
 
 fun <T : Any> T?.npe() : T =
   if (this == null)

examples/src/benchmarks/FList.kt

-namespace flist
+package flist
 
 abstract class FList<T> {
     abstract val head : T

examples/src/benchmarks/LockPerf.kt

-namespace lockperformance
+package lockperformance
 
 import std.io.*
 import std.util.*

examples/src/benchmarks/Quicksort.kt

-namespace quicksort
+package quicksort
 
 fun IntArray.swap(i:Int, j:Int) {
     val temp = this[i]

examples/src/benchmarks/SpectralNorm.kt

-namespace spectralnorm
+package spectralnorm
 
 import java.text.DecimalFormat;
 import java.text.NumberFormat;

examples/src/benchmarks/ThreadRing.kt

-namespace threadring
+package threadring
 
 import java.util.concurrent.*;
 import java.util.concurrent.atomic.*;

examples/src/collections/IIterable.kt

-namespace jet.collections.iterable
+package jet.collections.iterable
 
 import jet.collections.iterator.IIterator
 

examples/src/collections/ISet.kt

-namespace jet.collections.set
+package jet.collections.set
 
 import jet.collections.sized.ISized
 import jet.collections.iterable.IIterable

examples/src/collections/ISized.kt

-namespace jet.collections.sized
+package jet.collections.sized
 
 trait ISized {
   val size : Int

examples/src/collections/Iterator.kt

-namespace jet.collections
+package jet.collections
 
 import java.util.NoSuchElementException
 

examples/src/netty/netty.kt

@@ -16,7 +16,7 @@ import org.jboss.netty.handler.codec.http.HttpResponseStatus.*
 import netty.*
 import jlstring.*
 
-namespace jlstring {
+package jlstring {
     fun String.replace(c: Char, by: Char) : String = (this as java.lang.String).replace(c, by) as String
 
     fun String.contains(s: String) : Boolean = (this as java.lang.String).contains(s as java.lang.CharSequence)
@@ -24,7 +24,7 @@ namespace jlstring {
     fun java.lang.String.plus(s: Any?) : String = (this as String) + s.toString()
 }
 
-namespace netty {
+package netty {
     fun ChannelPipeline.with(op: fun ChannelPipeline.() ) : ChannelPipeline {
         this.op()
         return this

idea/testData/checker/Abstract.jet

-namespace abstract
+package abstract
 
 class MyClass() {
     //properties
@@ -118,7 +118,7 @@ enum class MyEnum() {
 
 abstract enum class MyAbstractEnum() {}
 
-namespace MyNamespace {
+package MyNamespace {
     //properties
     val <error>a</error>: Int
     val a1: Int = 1

idea/testData/checker/Bounds.jet

-namespace boundsWithSubstitutors {
+package boundsWithSubstitutors {
     open class A<T>
     class B<X : A<X>>()
 

idea/testData/checker/ClassObjects.jet

-namespace Jet86
+package Jet86
 
 class A {
   class object {

idea/testData/checker/ExtensionFunctions.jet

@@ -37,7 +37,7 @@ val <T> T.<error>foo</error> : T
 
 fun Int.foo() = this
 
-namespace null_safety {
+package null_safety {
 
         fun parse(<warning>cmd</warning>: String): Command? { return null  }
         class Command() {

idea/testData/checker/GenericArgumentConsistency.jet

@@ -13,28 +13,28 @@ trait BB1 : BA1<Int> {}
 trait BB2 : <error>BA1<Any>, BB1</error> {}
 
 
-namespace x {
+package x {
     trait AA1<out T> {}
     trait AB1 : AA1<Int> {}
     trait AB3 : AA1<Comparable<Int>> {}
     trait AB2 : AA1<Number>, AB1, AB3 {}
 }
 
-namespace x2 {
+package x2 {
     trait AA1<out T> {}
     trait AB1 : AA1<Any> {}
     trait AB3 : AA1<Comparable<Int>> {}
     trait AB2 : <error>AA1<Number>, AB1, AB3</error> {}
 }
 
-namespace x3 {
+package x3 {
     trait AA1<in T> {}
     trait AB1 : AA1<Any> {}
     trait AB3 : AA1<Comparable<Int>> {}
     trait AB2 : AA1<Number>, AB1, AB3 {}
 }
 
-namespace sx2 {
+package sx2 {
     trait AA1<in T> {}
     trait AB1 : AA1<Int> {}
     trait AB3 : AA1<Comparable<Int>> {}

idea/testData/checker/MultipleBounds.jet

-namespace Jet87
+package Jet87
 
 open class A() {
   fun foo() : Int = 1

idea/testData/checker/NamespaceAsExpression.jet

-namespace root
+package root
 
-namespace a {
+package a {
 
 }
 
 val x = <error>a</error>
-val y2 = <error>namespace</error>
+val y2 = <error>package</error>

idea/testData/checker/NamespaceQualified.jet

-namespace foobar
+package foobar
 
-namespace a {
+package a {
     import java.*
 
     val a : util.List<Int>? = null
@@ -12,7 +12,7 @@ abstract class Foo<T>() {
     abstract val x : T<Int>
 }
 
-namespace a {
+package a {
     import java.util.*
 
     val b : List<Int>? = a

idea/testData/checker/Objects.jet

-namespace toplevelObjectDeclarations {
+package toplevelObjectDeclarations {
   open class Foo(y : Int) {
     open fun foo() : Int = 1
   }
@@ -28,7 +28,7 @@ namespace toplevelObjectDeclarations {
   val z = y.foo()
 }
 
-namespace nestedObejcts {
+package nestedObejcts {
   object A {
     val b = B
     val d = A.B.A
@@ -58,7 +58,7 @@ namespace nestedObejcts {
   val e = B.<error>A</error>.B
 }
 
-namespace localObjects {
+package localObjects {
   object A {
     val x : Int = 0
   }

idea/testData/checker/Override.jet

-namespace override
+package override
 
-namespace normal {
+package normal {
     trait MyTrait {
         fun foo()
     }
@@ -37,7 +37,7 @@ namespace normal {
     }
 }
 
-namespace generics {
+package generics {
     trait MyTrait<T> {
         fun foo(t: T) : T
     }

idea/testData/checker/QualifiedExpressions.jet

-namespace qualified_expressions
+package qualified_expressions
 
 fun test(s: String?) {
    val <warning>a</warning>: Int = <error>s?.length</error>

idea/testData/checker/QualifiedThis.jet

@@ -21,7 +21,7 @@ fun foo1() : Unit {
   this<error>@a</error>
 }
 
-namespace closures {
+package closures {
     class A(val a:Int) {
 
       class B() {

idea/testData/checker/Redeclarations.jet

-namespace redeclarations {
+package redeclarations {
   object <error>A</error> {
     val x : Int = 0
 
     val A = 1
   }
 
-  namespace <error>A</error> {
+  package <error>A</error> {
     class A {}
   }
 

idea/testData/checker/ResolveToJava.jet

@@ -47,6 +47,6 @@ fun test(<warning>l</warning> : java.util.List<Int>) {
 }
 
 
-namespace xxx {
+package xxx {
   import java.lang.Class;
 }

idea/testData/checker/Variance.jet

-namespace variance
+package variance
 
 abstract class Consumer<in T> {}
 

idea/testData/checker/regression/AmbiguityOnLazyTypeComputation.jet

 // One of the two passes is making a scope and turning vals into functions
 // See KT-76
 
-namespace x
+package x
 
 val b : Foo = Foo()
 val a1 = b.compareTo(2)

idea/testData/completion/basic/ExtendQualifiedClassName.kt

-namespace Test.SubTest.AnotherTest
+package Test.SubTest.AnotherTest
 
 open class TestClass {
 }

idea/testData/completion/basic/FromImports.kt

-namespace Tests
+package Tests
 
 import java.util.*
 

idea/testData/completion/basic/JavaPackage.kt

-namespace Tests
+package Tests
 
 class A : java.<caret>
 

idea/testData/completion/basic/OverloadFunctions.kt

-namespace Test.MyTest
+package Test.MyTest
 
 class A {
     class object {

idea/testData/completion/basic/SubpackageInFun.kt

-namespace Test.MyTest
+package Test.MyTest
 
 fun test() {
     Test.<caret>

idea/testData/completion/basic/extensions/ExtensionInExtendedClass.kt

-namespace Test
+package Test
 
 class Some() {
     fun methodName() {

idea/testData/completion/handlers/SingleBrackets.kt

-namespace Test.MyTest
+package Test.MyTest
 
 class A {
     class object {

idea/testData/completion/handlers/SingleBrackets.kt.after

-namespace Test.MyTest
+package Test.MyTest
 
 class A {
     class object {

idea/testData/quickfix/abstract/afterNonMemberFunctionNoBody.kt

 // "Add function body" "true"
-namespace a {
+package a {
 fun <caret>foo() {
 }
 }
\ No newline at end of file