diff --git a/compiler/android-tests/src/org/jetbrains/jet/compiler/CodegenTestsOnAndroidRunner.java b/compiler/android-tests/src/org/jetbrains/jet/compiler/CodegenTestsOnAndroidRunner.java index 5812a3521f3..f74f4d89c88 100644 --- a/compiler/android-tests/src/org/jetbrains/jet/compiler/CodegenTestsOnAndroidRunner.java +++ b/compiler/android-tests/src/org/jetbrains/jet/compiler/CodegenTestsOnAndroidRunner.java @@ -114,9 +114,9 @@ public class CodegenTestsOnAndroidRunner { [exec] at java.lang.reflect.Method.invokeNative(Native Method) [exec] at org.jetbrains.jet.compiler.android.AbstractCodegenTestCaseOnAndroid.invokeBoxMethod(AbstractCodegenTestCaseOnAndroid.java:35) [exec] ... 13 more - [exec] Caused by: java.lang.VerifyError: compiler_testData_codegen_regressions_kt344_jet.namespace$t6$foo$1 - [exec] at compiler_testData_codegen_regressions_kt344_jet.namespace.t6(dummy.jet:94) - [exec] at compiler_testData_codegen_regressions_kt344_jet.namespace.box(dummy.jet:185) + [exec] Caused by: java.lang.VerifyError: compiler_testData_codegen_boxWithStdlib_regressions_kt344_kt.Compiler_testData_codegen_boxWithStdlib_regressions_kt344_ktPackage$t6$foo$1 + [exec] at compiler_testData_codegen_boxWithStdlib_regressions_kt344_kt.Compiler_testData_codegen_boxWithStdlib_regressions_kt344_ktPackage.t6(dummy.jet:94) + [exec] at compiler_testData_codegen_boxWithStdlib_regressions_kt344_kt.Compiler_testData_codegen_boxWithStdlib_regressions_kt344_ktPackage.box(dummy.jet:185) [exec] ... 16 more [exec] ............... [exec] Error in testKt529: diff --git a/compiler/android-tests/tests/org/jetbrains/jet/compiler/android/CodegenTestsOnAndroidGenerator.java b/compiler/android-tests/tests/org/jetbrains/jet/compiler/android/CodegenTestsOnAndroidGenerator.java index 394a924d539..21863a129fc 100644 --- a/compiler/android-tests/tests/org/jetbrains/jet/compiler/android/CodegenTestsOnAndroidGenerator.java +++ b/compiler/android-tests/tests/org/jetbrains/jet/compiler/android/CodegenTestsOnAndroidGenerator.java @@ -180,10 +180,10 @@ public class CodegenTestsOnAndroidGenerator extends UsefulTestCase { } } - private static void generateTestMethod(Printer p, String testName, String namespace) { + private static void generateTestMethod(Printer p, String testName, String packageName) { p.println("public void test" + testName + "() throws Exception {"); p.pushIndent(); - p.println("invokeBoxMethod(\"" + namespace + "\", \"OK\");"); + p.println("invokeBoxMethod(\"" + packageName + "\", \"OK\");"); p.popIndent(); p.println("}"); p.println(); diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java index 309a2671f8f..f245b2945be 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java @@ -349,7 +349,7 @@ public class FunctionCodegen extends ParentCodegenAwareImpl { InstructionAdapter iv = new InstructionAdapter(mv); Type[] argTypes = asmMethod.getArgumentTypes(); - // The first line of some namespace file is written to the line number attribute of a static delegate to allow to 'step into' it + // The first line of some package file is written to the line number attribute of a static delegate to allow to 'step into' it // This is similar to what javac does with bridge methods Label label = new Label(); iv.visitLabel(label); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JetFilesProvider.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JetFilesProvider.java index 13c4f8f9dd4..c3b2ec8a4fa 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JetFilesProvider.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JetFilesProvider.java @@ -35,7 +35,7 @@ public abstract class JetFilesProvider { return ServiceManager.getService(project, JetFilesProvider.class); } - public final Function> allNamespaceFiles() { + public final Function> allPackageFiles() { return new Function>() { @Override public Collection fun(JetFile file) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/parsing/JetExpressionParsing.java b/compiler/frontend/src/org/jetbrains/jet/lang/parsing/JetExpressionParsing.java index 9d1c6a6af70..654d93e4ac8 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/parsing/JetExpressionParsing.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/parsing/JetExpressionParsing.java @@ -529,7 +529,7 @@ public class JetExpressionParsing extends AbstractJetParsing { * : functionLiteral * : declaration * : SimpleName - * : "package" // foo the root namespace + * : "package" // for the root package * ; */ private void parseAtomicExpression() { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetImportDirective.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetImportDirective.java index c1a9a3698a2..0dbb24a3064 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetImportDirective.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetImportDirective.java @@ -37,7 +37,7 @@ public class JetImportDirective extends JetElementImpl { return visitor.visitImportDirective(this, data); } - public boolean isAbsoluteInRootNamespace() { + public boolean isAbsoluteInRootPackage() { return findChildByType(JetTokens.PACKAGE_KEYWORD) != null; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiFactory.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiFactory.java index d4721450e42..43446672155 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiFactory.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiFactory.java @@ -301,8 +301,8 @@ public class JetPsiFactory { importDirectiveBuilder.append(" as ").append(alias.asString()); } - JetFile namespace = createFile(project, importDirectiveBuilder.toString()); - return namespace.getImportDirectives().iterator().next(); + JetFile file = createFile(project, importDirectiveBuilder.toString()); + return file.getImportDirectives().iterator().next(); } @NotNull diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetUserType.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetUserType.java index 6cb9ebfbf0a..e38c25ec868 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetUserType.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetUserType.java @@ -31,7 +31,7 @@ public class JetUserType extends JetTypeElement { super(node); } - public boolean isAbsoluteInRootNamespace() { + public boolean isAbsoluteInRootPackage() { return findChildByType(JetTokens.PACKAGE_KEYWORD) != null; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContextUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContextUtils.java index aa6b3a4a4cb..4aa81ff10a6 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContextUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContextUtils.java @@ -89,7 +89,7 @@ public class BindingContextUtils { @Nullable public static JetFile getContainingFile(@NotNull BindingContext context, @NotNull DeclarationDescriptor declarationDescriptor) { // declarationDescriptor may describe a synthesized element which doesn't have PSI - // To workaround that, we find a top-level parent (which is inside a NamespaceDescriptor), which is guaranteed to have PSI + // To workaround that, we find a top-level parent (which is inside a PackageFragmentDescriptor), which is guaranteed to have PSI DeclarationDescriptor descriptor = DescriptorUtils.findTopLevelParent(declarationDescriptor); if (descriptor == null) return null; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationResolver.java index dde25c62b57..922c5506ccc 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationResolver.java @@ -98,7 +98,7 @@ public class DeclarationResolver { resolveFunctionAndPropertyHeaders(); createFunctionsForDataClasses(); importsResolver.processMembersImports(); - checkRedeclarationsInNamespaces(); + checkRedeclarationsInPackages(); checkRedeclarationsInInnerClassNames(); } @@ -161,12 +161,12 @@ public class DeclarationResolver { } private void resolveFunctionAndPropertyHeaders() { - for (Map.Entry entry : context.getNamespaceScopes().entrySet()) { - JetFile namespace = entry.getKey(); - WritableScope namespaceScope = entry.getValue(); - PackageLikeBuilder packageBuilder = context.getPackageFragments().get(namespace).getBuilder(); + for (Map.Entry entry : context.getFileScopes().entrySet()) { + JetFile file = entry.getKey(); + WritableScope fileScope = entry.getValue(); + PackageLikeBuilder packageBuilder = context.getPackageFragments().get(file).getBuilder(); - resolveFunctionAndPropertyHeaders(namespace.getDeclarations(), namespaceScope, namespaceScope, namespaceScope, packageBuilder); + resolveFunctionAndPropertyHeaders(file.getDeclarations(), fileScope, fileScope, fileScope, packageBuilder); } for (Map.Entry entry : context.getClasses().entrySet()) { JetClassOrObject classOrObject = entry.getKey(); @@ -317,7 +317,7 @@ public class DeclarationResolver { } } - private void checkRedeclarationsInNamespaces() { + private void checkRedeclarationsInPackages() { for (MutablePackageFragmentDescriptor packageFragment : Sets.newHashSet(context.getPackageFragments().values())) { if (KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME.equals(packageFragment.getFqName())) { // TODO: drop this after built-ins are fully rewritten to Kotlin diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/Importer.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/Importer.java index 861f20d029d..c04e7efd6cc 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/Importer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/Importer.java @@ -48,10 +48,10 @@ public interface Importer { }; class StandardImporter implements Importer { - private final WritableScope namespaceScope; + private final WritableScope fileScope; - public StandardImporter(WritableScope namespaceScope) { - this.namespaceScope = namespaceScope; + public StandardImporter(WritableScope fileScope) { + this.fileScope = fileScope; } @Override @@ -101,22 +101,22 @@ public interface Importer { } for (JetScope scope : scopesToImport) { - namespaceScope.importScope(createFilteringScope(scope, descriptor, platformToKotlinClassMap)); + fileScope.importScope(createFilteringScope(scope, descriptor, platformToKotlinClassMap)); } } protected void importDeclarationAlias(@NotNull DeclarationDescriptor descriptor, @NotNull Name aliasName) { if (descriptor instanceof ClassifierDescriptor) { - namespaceScope.importClassifierAlias(aliasName, (ClassifierDescriptor) descriptor); + fileScope.importClassifierAlias(aliasName, (ClassifierDescriptor) descriptor); } else if (descriptor instanceof PackageViewDescriptor) { - namespaceScope.importPackageAlias(aliasName, (PackageViewDescriptor) descriptor); + fileScope.importPackageAlias(aliasName, (PackageViewDescriptor) descriptor); } else if (descriptor instanceof FunctionDescriptor) { - namespaceScope.importFunctionAlias(aliasName, (FunctionDescriptor) descriptor); + fileScope.importFunctionAlias(aliasName, (FunctionDescriptor) descriptor); } else if (descriptor instanceof VariableDescriptor) { - namespaceScope.importVariableAlias(aliasName, (VariableDescriptor) descriptor); + fileScope.importVariableAlias(aliasName, (VariableDescriptor) descriptor); } } @@ -137,8 +137,8 @@ public interface Importer { private final List imports = Lists.newArrayList(); - public DelayedImporter(@NotNull WritableScope namespaceScope) { - super(namespaceScope); + public DelayedImporter(@NotNull WritableScope fileScope) { + super(fileScope); } @Override diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java index 4158b07464b..22590033045 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java @@ -82,8 +82,8 @@ public class ImportsResolver { private void processImports(@NotNull LookupMode lookupMode) { for (JetFile file : context.getPackageFragments().keySet()) { - WritableScope namespaceScope = context.getNamespaceScopes().get(file); - processImportsInFile(lookupMode, namespaceScope, Lists.newArrayList(file.getImportDirectives())); + WritableScope fileScope = context.getFileScopes().get(file); + processImportsInFile(lookupMode, fileScope, Lists.newArrayList(file.getImportDirectives())); } for (JetScript script : context.getScripts().keySet()) { WritableScope scriptScope = context.getScriptScopes().get(script); @@ -97,7 +97,7 @@ public class ImportsResolver { private static void processImportsInFile( LookupMode lookupMode, - @NotNull WritableScope namespaceScope, + @NotNull WritableScope fileScope, @NotNull List importDirectives, @NotNull ModuleDescriptor module, @NotNull BindingTrace trace, @@ -106,9 +106,9 @@ public class ImportsResolver { ) { @NotNull JetScope rootScope = module.getPackage(FqName.ROOT).getMemberScope(); - Importer.DelayedImporter delayedImporter = new Importer.DelayedImporter(namespaceScope); + Importer.DelayedImporter delayedImporter = new Importer.DelayedImporter(fileScope); if (lookupMode == LookupMode.EVERYTHING) { - namespaceScope.clearImports(); + fileScope.clearImports(); } for (ImportPath defaultImportPath : module.getDefaultImports()) { @@ -116,7 +116,7 @@ public class ImportsResolver { trace, "transient trace to resolve default imports"); //not to trace errors of default imports JetImportDirective defaultImportDirective = importsFactory.createImportDirective(defaultImportPath); - qualifiedExpressionResolver.processImportReference(defaultImportDirective, rootScope, namespaceScope, delayedImporter, + qualifiedExpressionResolver.processImportReference(defaultImportDirective, rootScope, fileScope, delayedImporter, temporaryTrace, module, lookupMode); } @@ -124,7 +124,7 @@ public class ImportsResolver { for (JetImportDirective importDirective : importDirectives) { Collection descriptors = - qualifiedExpressionResolver.processImportReference(importDirective, rootScope, namespaceScope, delayedImporter, + qualifiedExpressionResolver.processImportReference(importDirective, rootScope, fileScope, delayedImporter, trace, module, lookupMode); if (!descriptors.isEmpty()) { resolvedDirectives.put(importDirective, descriptors); @@ -141,7 +141,7 @@ public class ImportsResolver { if (lookupMode == LookupMode.EVERYTHING) { for (JetImportDirective importDirective : importDirectives) { - reportUselessImport(importDirective, namespaceScope, resolvedDirectives, trace); + reportUselessImport(importDirective, fileScope, resolvedDirectives, trace); } } } @@ -163,7 +163,7 @@ public class ImportsResolver { private static void reportUselessImport( @NotNull JetImportDirective importDirective, - @NotNull WritableScope namespaceScope, + @NotNull WritableScope fileScope, @NotNull Map> resolvedDirectives, @NotNull BindingTrace trace ) { @@ -181,13 +181,13 @@ public class ImportsResolver { for (DeclarationDescriptor wasResolved : resolvedDirectives.get(importDirective)) { DeclarationDescriptor isResolved = null; if (wasResolved instanceof ClassDescriptor) { - isResolved = namespaceScope.getClassifier(aliasName); + isResolved = fileScope.getClassifier(aliasName); } else if (wasResolved instanceof VariableDescriptor) { - isResolved = namespaceScope.getLocalVariable(aliasName); + isResolved = fileScope.getLocalVariable(aliasName); } else if (wasResolved instanceof PackageViewDescriptor) { - isResolved = namespaceScope.getPackage(aliasName); + isResolved = fileScope.getPackage(aliasName); } if (isResolved == null || isResolved.equals(wasResolved)) { uselessHiddenImport = false; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/JetModuleUtil.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/JetModuleUtil.java index e881aa9b04d..22d6ecea5ad 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/JetModuleUtil.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/JetModuleUtil.java @@ -24,7 +24,7 @@ import org.jetbrains.jet.lang.types.PackageType; public class JetModuleUtil { public static PackageType getRootPackageType(JetElement expression) { - // TODO: this is a stub: at least the modules' root namespaces must be indexed here + // TODO: this is a stub: at least the modules' root packages must be indexed here return new PackageType(SpecialNames.ROOT_PACKAGE, JetScope.EMPTY, ReceiverValue.NO_RECEIVER); } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/QualifiedExpressionResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/QualifiedExpressionResolver.java index 71755838ab5..89d1a3cfba6 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/QualifiedExpressionResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/QualifiedExpressionResolver.java @@ -35,7 +35,7 @@ import java.util.Set; import static org.jetbrains.jet.lang.diagnostics.Errors.*; public class QualifiedExpressionResolver { - private static final Predicate CLASSIFIERS_AND_NAMESPACES = new Predicate() { + private static final Predicate CLASSIFIERS_AND_PACKAGE_VIEWS = new Predicate() { @Override public boolean apply(@Nullable DeclarationDescriptor descriptor) { return descriptor instanceof ClassifierDescriptor || descriptor instanceof PackageViewDescriptor; @@ -70,7 +70,7 @@ public class QualifiedExpressionResolver { @NotNull ModuleDescriptor module, @NotNull LookupMode lookupMode ) { - if (importDirective.isAbsoluteInRootNamespace()) { + if (importDirective.isAbsoluteInRootPackage()) { trace.report(UNSUPPORTED.on(importDirective, "TypeHierarchyResolver")); // TODO return Collections.emptyList(); } @@ -158,7 +158,7 @@ public class QualifiedExpressionResolver { public Collection lookupDescriptorsForUserType(@NotNull JetUserType userType, @NotNull JetScope outerScope, @NotNull BindingTrace trace) { - if (userType.isAbsoluteInRootNamespace()) { + if (userType.isAbsoluteInRootPackage()) { trace.report(Errors.UNSUPPORTED.on(userType, "package")); return Collections.emptyList(); } @@ -241,9 +241,9 @@ public class QualifiedExpressionResolver { @NotNull public Collection lookupDescriptorsForSimpleNameReference(@NotNull JetSimpleNameExpression referenceExpression, - @NotNull JetScope outerScope, @NotNull JetScope scopeToCheckVisibility, @NotNull BindingTrace trace, @NotNull LookupMode lookupMode, boolean namespaceLevel, boolean storeResult) { + @NotNull JetScope outerScope, @NotNull JetScope scopeToCheckVisibility, @NotNull BindingTrace trace, @NotNull LookupMode lookupMode, boolean packageLevel, boolean storeResult) { - LookupResult lookupResult = lookupSimpleNameReference(referenceExpression, outerScope, lookupMode, namespaceLevel); + LookupResult lookupResult = lookupSimpleNameReference(referenceExpression, outerScope, lookupMode, packageLevel); if (lookupResult == LookupResult.EMPTY) return Collections.emptyList(); return filterAndStoreResolutionResult(Collections.singletonList((SuccessfulLookupResult)lookupResult), referenceExpression, trace, scopeToCheckVisibility, lookupMode, storeResult); @@ -251,7 +251,7 @@ public class QualifiedExpressionResolver { @NotNull private LookupResult lookupSimpleNameReference(@NotNull JetSimpleNameExpression referenceExpression, - @NotNull JetScope outerScope, @NotNull LookupMode lookupMode, boolean namespaceLevel) { + @NotNull JetScope outerScope, @NotNull LookupMode lookupMode, boolean packageLevel) { Name referencedName = referenceExpression.getReferencedNameAsName(); @@ -275,7 +275,7 @@ public class QualifiedExpressionResolver { descriptors.add(localVariable); } } - return new SuccessfulLookupResult(descriptors, outerScope, namespaceLevel); + return new SuccessfulLookupResult(descriptors, outerScope, packageLevel); } @NotNull @@ -305,17 +305,17 @@ public class QualifiedExpressionResolver { Collection filteredDescriptors; if (lookupMode == LookupMode.ONLY_CLASSES) { - filteredDescriptors = Collections2.filter(descriptors, CLASSIFIERS_AND_NAMESPACES); + filteredDescriptors = Collections2.filter(descriptors, CLASSIFIERS_AND_PACKAGE_VIEWS); } else { filteredDescriptors = Sets.newLinkedHashSet(); - //functions and properties can be imported if lookupResult.namespaceLevel == true + //functions and properties can be imported if lookupResult.packageLevel == true for (SuccessfulLookupResult lookupResult : lookupResults) { - if (lookupResult.namespaceLevel) { + if (lookupResult.packageLevel) { filteredDescriptors.addAll(lookupResult.descriptors); continue; } - filteredDescriptors.addAll(Collections2.filter(lookupResult.descriptors, CLASSIFIERS_AND_NAMESPACES)); + filteredDescriptors.addAll(Collections2.filter(lookupResult.descriptors, CLASSIFIERS_AND_PACKAGE_VIEWS)); } } if (storeResult) { @@ -338,7 +338,7 @@ public class QualifiedExpressionResolver { JetScope resolutionScope = possibleResolutionScopes.iterator().next(); // A special case - will fill all trace information - if (resolveClassNamespaceAmbiguity(canBeImportedDescriptors, referenceExpression, resolutionScope, trace, scopeToCheckVisibility)) { + if (resolveClassPackageAmbiguity(canBeImportedDescriptors, referenceExpression, resolutionScope, trace, scopeToCheckVisibility)) { return; } @@ -379,14 +379,18 @@ public class QualifiedExpressionResolver { } /** - * This method tries to resolve descriptors ambiguity between class descriptor and namespace descriptor for the same class. + * This method tries to resolve descriptors ambiguity between class descriptor and package descriptor for the same class. * It's ok choose class for expression reference resolution. * * @return true if method has successfully resolved ambiguity */ - private boolean resolveClassNamespaceAmbiguity(@NotNull Collection filteredDescriptors, - @NotNull JetSimpleNameExpression referenceExpression, @NotNull JetScope resolutionScope, @NotNull BindingTrace trace, - @NotNull JetScope scopeToCheckVisibility) { + private boolean resolveClassPackageAmbiguity( + @NotNull Collection filteredDescriptors, + @NotNull JetSimpleNameExpression referenceExpression, + @NotNull JetScope resolutionScope, + @NotNull BindingTrace trace, + @NotNull JetScope scopeToCheckVisibility + ) { if (filteredDescriptors.size() == 2) { PackageViewDescriptor packageView = null; @@ -430,14 +434,15 @@ public class QualifiedExpressionResolver { private static class SuccessfulLookupResult implements LookupResult { final Collection descriptors; final JetScope resolutionScope; - final boolean namespaceLevel; + final boolean packageLevel; private SuccessfulLookupResult(Collection descriptors, JetScope resolutionScope, - boolean namespaceLevel) { + boolean packageLevel + ) { this.descriptors = descriptors; this.resolutionScope = resolutionScope; - this.namespaceLevel = namespaceLevel; + this.packageLevel = packageLevel; } } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java index cc7dd06e345..82a161eada8 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java @@ -52,7 +52,7 @@ public class TopDownAnalysisContext implements BodiesResolveContext { private Map members = null; // File scopes - package scope extended with imports - protected final Map namespaceScopes = Maps.newHashMap(); + protected final Map fileScopes = Maps.newHashMap(); public final Map forDeferredResolver = Maps.newHashMap(); @@ -110,8 +110,8 @@ public class TopDownAnalysisContext implements BodiesResolveContext { return classes; } - public Map getNamespaceScopes() { - return namespaceScopes; + public Map getFileScopes() { + return fileScopes; } public Map getPackageFragments() { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java index 599b2fa6e0d..23023eb003a 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java @@ -143,7 +143,7 @@ public class TopDownAnalyzer { mutableClassDescriptor.lockScopes(); } Set scriptFqNames = Sets.newHashSet(); - for (JetFile file : context.getNamespaceScopes().keySet()) { + for (JetFile file : context.getFileScopes().keySet()) { if (file.isScript()) { scriptFqNames.add(JetPsiUtil.getFQName(file)); } @@ -213,13 +213,13 @@ public class TopDownAnalyzer { // "depend on" builtins module ((ModuleDescriptorImpl) moduleDescriptor).addFragmentProvider(KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider()); - // Import a scope that contains all top-level namespaces that come from dependencies - // This makes the namespaces visible at all, does not import themselves + // Import a scope that contains all top-level packages that come from dependencies + // This makes the package visible at all, does not import themselves PackageViewDescriptor rootPackage = moduleDescriptor.getPackage(FqName.ROOT); assert rootPackage != null : "Coulnd't find root package for " + moduleDescriptor; // dummy builder is used because "root" is module descriptor, - // namespaces added to module explicitly in + // packages added to module explicitly in doProcess(rootPackage.getMemberScope(), new PackageLikeBuilderDummy(), files); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java index 26448298fa4..bafce4c99e8 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java @@ -96,9 +96,9 @@ public class TypeHierarchyResolver { ) { { - // TODO: Very temp code - main goal is to remove recursion from collectNamespacesAndClassifiers + // TODO: Very temp code - main goal is to remove recursion from collectPackageFragmentsAndClassifiers Queue forDeferredResolve = new LinkedList(); - forDeferredResolve.addAll(collectNamespacesAndClassifiers(outerScope, owner, declarations)); + forDeferredResolve.addAll(collectPackageFragmentsAndClassifiers(outerScope, owner, declarations)); while (!forDeferredResolve.isEmpty()) { JetDeclarationContainer declarationContainer = forDeferredResolve.poll(); @@ -110,14 +110,14 @@ public class TypeHierarchyResolver { // Even more temp code if (descriptorForDeferredResolve instanceof MutableClassDescriptorLite) { forDeferredResolve.addAll( - collectNamespacesAndClassifiers( + collectPackageFragmentsAndClassifiers( scope, ((MutableClassDescriptorLite) descriptorForDeferredResolve).getBuilder(), declarationContainer.getDeclarations())); } else if (descriptorForDeferredResolve instanceof MutablePackageFragmentDescriptor) { forDeferredResolve.addAll( - collectNamespacesAndClassifiers( + collectPackageFragmentsAndClassifiers( scope, ((MutablePackageFragmentDescriptor) descriptorForDeferredResolve).getBuilder(), declarationContainer.getDeclarations())); @@ -147,7 +147,7 @@ public class TypeHierarchyResolver { } @NotNull - private Collection collectNamespacesAndClassifiers( + private Collection collectPackageFragmentsAndClassifiers( @NotNull JetScope outerScope, @NotNull PackageLikeBuilder owner, @NotNull Iterable declarations @@ -465,7 +465,7 @@ public class TypeHierarchyResolver { WriteThroughScope packageScope = new WriteThroughScope(rootPlusPackageScope, packageFragment.getMemberScope(), new TraceBasedRedeclarationHandler(trace), "package in file " + file.getName()); packageScope.changeLockLevel(WritableScope.LockLevel.BOTH); - context.getNamespaceScopes().put(file, packageScope); + context.getFileScopes().put(file, packageScope); if (file.isScript()) { scriptHeaderResolver.processScriptHierarchy(file.getScript(), packageScope); @@ -560,7 +560,7 @@ public class TypeHierarchyResolver { trace.record(BindingContext.FILE_TO_PACKAGE_FRAGMENT, file, fragment); - // Register files corresponding to this namespace + // Register files corresponding to this package // The trace currently does not support bi-di multimaps that would handle this task nicer FqName fqName = fragment.getFqName(); Collection files = trace.get(PACKAGE_TO_FILES, fqName); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallExpressionResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallExpressionResolver.java index 129953c148b..27dd9129146 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallExpressionResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallExpressionResolver.java @@ -77,7 +77,7 @@ public class CallExpressionResolver { } @Nullable - private JetType lookupNamespaceOrClassObject(@NotNull JetSimpleNameExpression expression, @NotNull ExpressionTypingContext context) { + private JetType lookupPackageOrClassObject(@NotNull JetSimpleNameExpression expression, @NotNull ExpressionTypingContext context) { Name referencedName = expression.getReferencedNameAsName(); final ClassifierDescriptor classifier = context.scope.getClassifier(referencedName); if (classifier != null) { @@ -91,12 +91,12 @@ public class CallExpressionResolver { } JetType[] result = new JetType[1]; TemporaryBindingTrace temporaryTrace = TemporaryBindingTrace.create( - context.trace, "trace for namespace/class object lookup of name", referencedName); + context.trace, "trace for package/class object lookup of name", referencedName); if (furtherNameLookup(expression, result, context.replaceBindingTrace(temporaryTrace))) { temporaryTrace.commit(); return DataFlowUtils.checkType(result[0], expression, context); } - // To report NO_CLASS_OBJECT when no namespace found + // To report NO_CLASS_OBJECT when no package found if (classifier != null) { if (classifier instanceof TypeParameterDescriptor) { if (isLHSOfDot(expression)) { @@ -172,10 +172,10 @@ public class CallExpressionResolver { scopes.add(getStaticNestedClassesScope(classDescriptor)); Name referencedName = expression.getReferencedNameAsName(); - PackageViewDescriptor namespace = context.scope.getPackage(referencedName); - if (namespace != null) { + PackageViewDescriptor packageView = context.scope.getPackage(referencedName); + if (packageView != null) { //for enums loaded from java binaries - scopes.add(namespace.getMemberScope()); + scopes.add(packageView.getMemberScope()); } JetScope scope = new ChainedScope( @@ -265,11 +265,11 @@ public class CallExpressionResolver { ExpressionTypingContext newContext = receiver.exists() ? context.replaceScope(receiver.getType().getMemberScope()) : context; - TemporaryTraceAndCache temporaryForNamespaceOrClassObject = TemporaryTraceAndCache.create( - context, "trace to resolve as namespace or class object", nameExpression); - JetType jetType = lookupNamespaceOrClassObject(nameExpression, newContext.replaceTraceAndCache(temporaryForNamespaceOrClassObject)); + TemporaryTraceAndCache temporaryForPackageOrClassObject = TemporaryTraceAndCache.create( + context, "trace to resolve as package or class object", nameExpression); + JetType jetType = lookupPackageOrClassObject(nameExpression, newContext.replaceTraceAndCache(temporaryForPackageOrClassObject)); if (jetType != null) { - temporaryForNamespaceOrClassObject.commit(); + temporaryForPackageOrClassObject.commit(); // Uncommitted changes in temp context context.trace.record(RESOLUTION_SCOPE, nameExpression, context.scope); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowValueFactory.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowValueFactory.java index 858b90d2e4b..850601736f3 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowValueFactory.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowValueFactory.java @@ -89,12 +89,12 @@ public class DataFlowValueFactory { private static class IdentifierInfo { public final Object id; public final boolean isStable; - public final boolean isNamespace; + public final boolean isPackage; - private IdentifierInfo(Object id, boolean isStable, boolean isNamespace) { + private IdentifierInfo(Object id, boolean isStable, boolean isPackage) { this.id = id; this.isStable = isStable; - this.isNamespace = isNamespace; + this.isPackage = isPackage; } } @@ -120,7 +120,7 @@ public class DataFlowValueFactory { if (selectorInfo.id == null) { return NO_IDENTIFIER_INFO; } - if (receiverInfo == null || receiverInfo == NO_IDENTIFIER_INFO || receiverInfo.isNamespace) { + if (receiverInfo == null || receiverInfo == NO_IDENTIFIER_INFO || receiverInfo.isPackage) { return selectorInfo; } return createInfo(Pair.create(receiverInfo.id, selectorInfo.id), receiverInfo.isStable && selectorInfo.isStable); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/declarations/FileBasedPackageMemberDeclarationProvider.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/declarations/FileBasedPackageMemberDeclarationProvider.java index ade4c69ff2d..f2610bdfa88 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/declarations/FileBasedPackageMemberDeclarationProvider.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/declarations/FileBasedPackageMemberDeclarationProvider.java @@ -58,7 +58,7 @@ public class FileBasedPackageMemberDeclarationProvider extends AbstractPsiBasedD protected void doCreateIndex(@NotNull Index index) { for (JetFile file : packageFiles) { for (JetDeclaration declaration : file.getDeclarations()) { - assert fqName.asString().equals(file.getPackageName()) : "Files declaration utils contains file with invalid namespace"; + assert fqName.asString().equals(file.getPackageName()) : "Files declaration utils contains file with invalid package"; index.putToIndex(declaration); } } diff --git a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/StubClassBuilder.java b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/StubClassBuilder.java index 4bf4cce0907..647f1de85c5 100644 --- a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/StubClassBuilder.java +++ b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/StubClassBuilder.java @@ -51,7 +51,7 @@ public class StubClassBuilder extends ClassBuilder { private final StubElement parent; private StubBuildingVisitor v; private final Stack parentStack; - private boolean isNamespace = false; + private boolean isPackageClass = false; public StubClassBuilder(@NotNull Stack parentStack) { this.parentStack = parentStack; @@ -85,11 +85,11 @@ public class StubClassBuilder extends ClassBuilder { String packageClassName = PackageClassUtils.getPackageClassName(packageName); if (name.equals(packageClassName) || name.endsWith("/" + packageClassName)) { - isNamespace = true; + isPackageClass = true; } } - if (!isNamespace) { + if (!isPackageClass) { parentStack.push(v.getResult()); } @@ -150,7 +150,7 @@ public class StubClassBuilder extends ClassBuilder { @Override public void done() { - if (!isNamespace) { + if (!isPackageClass) { StubElement pop = parentStack.pop(); assert pop == v.getResult(); } diff --git a/compiler/tests/org/jetbrains/jet/JetTestUtils.java b/compiler/tests/org/jetbrains/jet/JetTestUtils.java index 0365020a41c..ee41f14278f 100644 --- a/compiler/tests/org/jetbrains/jet/JetTestUtils.java +++ b/compiler/tests/org/jetbrains/jet/JetTestUtils.java @@ -220,8 +220,8 @@ public class JetTestUtils { private JetTestUtils() { } - public static AnalyzeExhaust analyzeFile(@NotNull JetFile namespace) { - return AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(namespace, Collections.emptyList()); + public static AnalyzeExhaust analyzeFile(@NotNull JetFile file) { + return AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(file, Collections.emptyList()); } @NotNull diff --git a/compiler/tests/org/jetbrains/jet/codegen/JUnitUsageGenTest.java b/compiler/tests/org/jetbrains/jet/codegen/JUnitUsageGenTest.java index da8fea1a722..c2bceb0165c 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/JUnitUsageGenTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/JUnitUsageGenTest.java @@ -47,8 +47,8 @@ public class JUnitUsageGenTest extends CodegenTestCase { public void testKt1592() throws Exception { loadFile("junit/kt1592.kt"); - Class namespaceClass = generatePackageClass(); - Method method = namespaceClass.getMethod("foo", Method.class); + Class packageClass = generatePackageClass(); + Method method = packageClass.getMethod("foo", Method.class); method.setAccessible(true); Annotation annotation = method.getAnnotation(getCorrespondingAnnotationClass(Test.class)); assertEquals(ClassLoaderIsolationUtil.getAnnotationAttribute(annotation, "timeout"), 0l); diff --git a/compiler/tests/org/jetbrains/jet/codegen/KotlinClassAnnotationTest.java b/compiler/tests/org/jetbrains/jet/codegen/KotlinClassAnnotationTest.java index da5c08c04f9..909f0abe9c7 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/KotlinClassAnnotationTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/KotlinClassAnnotationTest.java @@ -30,7 +30,7 @@ import java.util.Set; import static org.jetbrains.jet.codegen.KotlinPackageAnnotationTest.collectCallableNames; public class KotlinClassAnnotationTest extends CodegenTestCase { - public static final FqName NAMESPACE_NAME = new FqName("test"); + public static final FqName PACKAGE_NAME = new FqName("test"); public static final FqNameUnsafe CLASS_NAME = new FqNameUnsafe("A"); @Override @@ -40,13 +40,13 @@ public class KotlinClassAnnotationTest extends CodegenTestCase { } public void testClassKotlinInfo() throws Exception { - loadText("package " + NAMESPACE_NAME + "\n" + + loadText("package " + PACKAGE_NAME + "\n" + "\n" + "class " + CLASS_NAME + " {\n" + " fun foo() {}\n" + " fun bar() = 42\n" + "}\n"); - Class aClass = generateClass(NAMESPACE_NAME + "." + CLASS_NAME); + Class aClass = generateClass(PACKAGE_NAME + "." + CLASS_NAME); Class annotationClass = getCorrespondingAnnotationClass(KotlinClass.class); assertTrue(aClass.isAnnotationPresent(annotationClass)); diff --git a/compiler/tests/org/jetbrains/jet/codegen/KotlinPackageAnnotationTest.java b/compiler/tests/org/jetbrains/jet/codegen/KotlinPackageAnnotationTest.java index 32a2e8f19dc..aaa9db1c355 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/KotlinPackageAnnotationTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/KotlinPackageAnnotationTest.java @@ -33,7 +33,7 @@ import java.util.List; import java.util.Set; public class KotlinPackageAnnotationTest extends CodegenTestCase { - public static final FqName NAMESPACE_NAME = new FqName("test"); + public static final FqName PACKAGE_NAME = new FqName("test"); @Override protected void setUp() throws Exception { @@ -42,7 +42,7 @@ public class KotlinPackageAnnotationTest extends CodegenTestCase { } public void testPackageKotlinInfo() throws Exception { - loadText("package " + NAMESPACE_NAME + "\n" + + loadText("package " + PACKAGE_NAME + "\n" + "\n" + "fun foo() = 42\n" + "val bar = 239\n" + @@ -50,7 +50,7 @@ public class KotlinPackageAnnotationTest extends CodegenTestCase { "class A\n" + "class B\n" + "object C\n"); - Class aClass = generateClass(PackageClassUtils.getPackageClassFqName(NAMESPACE_NAME).asString()); + Class aClass = generateClass(PackageClassUtils.getPackageClassFqName(PACKAGE_NAME).asString()); Class annotationClass = getCorrespondingAnnotationClass(KotlinPackage.class); assertTrue(aClass.isAnnotationPresent(annotationClass)); diff --git a/compiler/tests/org/jetbrains/jet/codegen/KotlinPackageFragmentAnnotationTest.java b/compiler/tests/org/jetbrains/jet/codegen/KotlinPackageFragmentAnnotationTest.java index ea5387c09da..5c0f79b18b3 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/KotlinPackageFragmentAnnotationTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/KotlinPackageFragmentAnnotationTest.java @@ -28,7 +28,7 @@ import org.jetbrains.jet.lang.resolve.name.FqName; import java.lang.annotation.Annotation; public class KotlinPackageFragmentAnnotationTest extends CodegenTestCase { - public static final FqName NAMESPACE_NAME = new FqName("test"); + public static final FqName PACKAGE_NAME = new FqName("test"); @Override protected void setUp() throws Exception { @@ -37,8 +37,8 @@ public class KotlinPackageFragmentAnnotationTest extends CodegenTestCase { } public void testKotlinPackageFragmentIsWritten() throws Exception { - loadText("package " + NAMESPACE_NAME + "\n\nfun foo() = 42\n"); - String facadeFileName = JvmClassName.byFqNameWithoutInnerClasses(PackageClassUtils.getPackageClassFqName(NAMESPACE_NAME)).getInternalName() + ".class"; + loadText("package " + PACKAGE_NAME + "\n\nfun foo() = 42\n"); + String facadeFileName = JvmClassName.byFqNameWithoutInnerClasses(PackageClassUtils.getPackageClassFqName(PACKAGE_NAME)).getInternalName() + ".class"; OutputFileCollection outputFiles = generateClassesInFile(); for (OutputFile outputFile : outputFiles.asList()) { diff --git a/compiler/tests/org/jetbrains/jet/codegen/LineNumberTest.java b/compiler/tests/org/jetbrains/jet/codegen/LineNumberTest.java index 13fe3c0ff29..9d6460ad0cb 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/LineNumberTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/LineNumberTest.java @@ -333,7 +333,7 @@ public class LineNumberTest extends TestCaseWithTmpdir { assertNotNull(file); ClassReader reader = new ClassReader(file.asByteArray()); - // There must be exactly one line number attribute for each static delegate in namespace.class, and it should point to the first + // There must be exactly one line number attribute for each static delegate in package facade class, and it should point to the first // line. There are two static delegates in this test, hence the [1, 1] List expectedLineNumbers = Arrays.asList(1, 1); List actualLineNumbers = readAllLineNumbers(reader); diff --git a/compiler/tests/org/jetbrains/jet/codegen/NamespaceGenTest.java b/compiler/tests/org/jetbrains/jet/codegen/PackageGenTest.java similarity index 99% rename from compiler/tests/org/jetbrains/jet/codegen/NamespaceGenTest.java rename to compiler/tests/org/jetbrains/jet/codegen/PackageGenTest.java index f15730b75bf..b6dfd30385a 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/NamespaceGenTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/PackageGenTest.java @@ -16,7 +16,6 @@ package org.jetbrains.jet.codegen; -import jet.IntRange; import org.jetbrains.jet.ConfigurationKind; import java.awt.*; @@ -27,7 +26,7 @@ import java.util.Arrays; import static org.jetbrains.jet.codegen.CodegenTestUtil.assertIsCurrentTime; -public class NamespaceGenTest extends CodegenTestCase { +public class PackageGenTest extends CodegenTestCase { @Override protected void setUp() throws Exception { diff --git a/compiler/tests/org/jetbrains/jet/codegen/PropertyGenTest.java b/compiler/tests/org/jetbrains/jet/codegen/PropertyGenTest.java index f42ab5cdcb0..1c9c72d55b1 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/PropertyGenTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/PropertyGenTest.java @@ -74,7 +74,7 @@ public class PropertyGenTest extends CodegenTestCase { assertNotNull(findDeclaredMethodByName(aClass, "setFoo")); } - public void testPrivatePropertyInNamespace() throws Exception { + public void testPrivatePropertyInPackage() throws Exception { loadText("private val x = 239"); Class nsClass = generatePackagePartClass(); Field[] fields = nsClass.getDeclaredFields(); @@ -135,7 +135,7 @@ public class PropertyGenTest extends CodegenTestCase { assertEquals(610, getFoo.invoke(instance)); } - public void testInitializersForNamespaceProperties() throws Exception { + public void testInitializersForTopLevelProperties() throws Exception { loadText("val x = System.currentTimeMillis()"); Method method = generateFunction("getX"); method.setAccessible(true); diff --git a/compiler/tests/org/jetbrains/jet/codegen/SourceInfoGenTest.java b/compiler/tests/org/jetbrains/jet/codegen/SourceInfoGenTest.java index 832a4c46287..d7bef3290f8 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/SourceInfoGenTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/SourceInfoGenTest.java @@ -28,13 +28,13 @@ public class SourceInfoGenTest extends CodegenTestCase { createEnvironmentWithMockJdkAndIdeaAnnotations(ConfigurationKind.JDK_ONLY); } - public void testSingleFileNamespace() { + public void testSingleFilePackage() { String producer = "sourceInfo/foo1.kt"; loadFiles(producer); assertEquals(producer, getProducerInfo("foo/FooPackage.class")); } - public void testMultiFileNamespace() { + public void testMultiFilePackage() { loadFiles("sourceInfo/foo1.kt", "sourceInfo/foo2.kt"); assertEquals(null, getProducerInfo("foo/FooPackage.class")); } diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java index 7c18b3c0afe..41311b335ed 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java @@ -56,7 +56,7 @@ import static org.jetbrains.jet.test.util.DescriptorValidator.ValidationVisitor. import static org.jetbrains.jet.test.util.RecursiveDescriptorComparator.*; /* - The generated test compares namespace descriptors loaded from kotlin sources and read from compiled java. + The generated test compares package descriptors loaded from kotlin sources and read from compiled java. */ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { protected void doTestCompiledJava(@NotNull String javaFileName) throws Exception { @@ -153,7 +153,7 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { injectorForAnalyzer.getTopDownAnalyzer().analyzeFiles(environment.getSourceFiles(), Collections.emptyList()); PackageViewDescriptor packageView = module.getPackage(TEST_PACKAGE_FQNAME); - assert packageView != null : "Test namespace not found"; + assert packageView != null : "Test package not found"; checkJavaPackage(expectedFile, packageView, trace.getBindingContext(), DONT_INCLUDE_METHODS_OF_OBJECT); } @@ -166,10 +166,10 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { assertTrue(testPackageDir.mkdir()); FileUtil.copy(originalJavaFile, new File(testPackageDir, originalJavaFile.getName())); - Pair javaNamespaceAndContext = loadTestPackageAndBindingContextFromJavaRoot( + Pair javaPackageAndContext = loadTestPackageAndBindingContextFromJavaRoot( tmpdir, getTestRootDisposable(), ConfigurationKind.JDK_ONLY); - checkJavaPackage(expectedFile, javaNamespaceAndContext.first, javaNamespaceAndContext.second, + checkJavaPackage(expectedFile, javaPackageAndContext.first, javaPackageAndContext.second, DONT_INCLUDE_METHODS_OF_OBJECT.withValidationStrategy(ALLOW_ERROR_TYPES)); } @@ -207,7 +207,7 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { private static void checkForLoadErrorsAndCompare( @NotNull PackageViewDescriptor javaPackage, @NotNull BindingContext bindingContext, - @NotNull Runnable compareNamespacesRunnable + @NotNull Runnable comparePackagesRunnable ) { boolean fail = false; try { @@ -225,7 +225,7 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { fail = true; } - compareNamespacesRunnable.run(); + comparePackagesRunnable.run(); if (fail) { fail("See error above"); } diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/CompileKotlinAgainstCustomBinariesTest.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/CompileKotlinAgainstCustomBinariesTest.java index 0993678cf7c..d9bc5151828 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/CompileKotlinAgainstCustomBinariesTest.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/CompileKotlinAgainstCustomBinariesTest.java @@ -81,7 +81,7 @@ public class CompileKotlinAgainstCustomBinariesTest extends TestCaseWithTmpdir { ); PackageViewDescriptor packageView = exhaust.getModuleDescriptor().getPackage(LoadDescriptorUtil.TEST_PACKAGE_FQNAME); - assertNotNull("Failed to find namespace: " + LoadDescriptorUtil.TEST_PACKAGE_FQNAME, packageView); + assertNotNull("Failed to find package: " + LoadDescriptorUtil.TEST_PACKAGE_FQNAME, packageView); return packageView; } diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDiagnosticsTest.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDiagnosticsTest.java index 443835f675b..5e5a257eea1 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDiagnosticsTest.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDiagnosticsTest.java @@ -50,7 +50,7 @@ public abstract class AbstractLazyResolveDiagnosticsTest extends BaseDiagnostics String txtFileRelativePath = path.replaceAll("\\.kt$|\\.ktscript", ".txt"); File txtFile = new File("compiler/testData/lazyResolve/diagnostics/" + txtFileRelativePath); - // Only recurse into those namespaces mentioned in the files + // Only recurse into those packages mentioned in the files // Otherwise we'll be examining the whole JDK final Set names = LazyResolveTestUtil.getTopLevelPackagesFromFileList(jetFiles); validateAndCompareDescriptors( diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveStdlibLoadingTest.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveStdlibLoadingTest.java index 6199ba64f31..af5f722e1d3 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveStdlibLoadingTest.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveStdlibLoadingTest.java @@ -46,12 +46,12 @@ public class LazyResolveStdlibLoadingTest extends KotlinTestWithEnvironmentManag protected void doTestForGivenFiles( List files ) { - Set namespaceShortNames = LazyResolveTestUtil.getTopLevelPackagesFromFileList(files); + Set packageShortNames = LazyResolveTestUtil.getTopLevelPackagesFromFileList(files); ModuleDescriptor module = LazyResolveTestUtil.resolveEagerly(files, stdlibEnvironment); ModuleDescriptor lazyModule = LazyResolveTestUtil.resolveLazily(files, stdlibEnvironment); - for (Name name : namespaceShortNames) { + for (Name name : packageShortNames) { PackageViewDescriptor eager = module.getPackage(FqName.topLevel(name)); PackageViewDescriptor lazy = lazyModule.getPackage(FqName.topLevel(name)); RecursiveDescriptorComparator.validateAndCompareDescriptors(eager, lazy, RecursiveDescriptorComparator.RECURSIVE, null); diff --git a/compiler/tests/org/jetbrains/jet/resolve/annotation/AbstractAnnotationDescriptorResolveTest.java b/compiler/tests/org/jetbrains/jet/resolve/annotation/AbstractAnnotationDescriptorResolveTest.java index 78290a0f8d6..a1221200cff 100644 --- a/compiler/tests/org/jetbrains/jet/resolve/annotation/AbstractAnnotationDescriptorResolveTest.java +++ b/compiler/tests/org/jetbrains/jet/resolve/annotation/AbstractAnnotationDescriptorResolveTest.java @@ -269,7 +269,7 @@ public abstract class AbstractAnnotationDescriptorResolveTest extends JetLiteFix context = analyzeExhaust.getBindingContext(); PackageViewDescriptor packageView = analyzeExhaust.getModuleDescriptor().getPackage(PACKAGE); - assertNotNull("Failed to find namespace: " + PACKAGE, packageView); + assertNotNull("Failed to find package: " + PACKAGE, packageView); return packageView; } diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java index 2f7bf5e5cea..6fc8649fc48 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java @@ -155,7 +155,7 @@ public final class JavaFunctionResolver { signatureErrors.addAll(effectiveSignature.getErrors()); } else { - throw new IllegalStateException("Unknown class or namespace descriptor: " + ownerDescriptor); + throw new IllegalStateException("Unknown class or package descriptor: " + ownerDescriptor); } functionDescriptorImpl.initialize( diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/AnnotationDescriptorDeserializer.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/AnnotationDescriptorDeserializer.java index 85002c2201b..efc99b6ffa4 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/AnnotationDescriptorDeserializer.java +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/AnnotationDescriptorDeserializer.java @@ -263,7 +263,7 @@ public class AnnotationDescriptorDeserializer implements AnnotationDeserializer } else if (isTrait(container) && kind == AnnotatedCallableKind.PROPERTY) { PackageFragmentDescriptor containingPackage = DescriptorUtils.getParentOfType(container, PackageFragmentDescriptor.class); - assert containingPackage != null : "Trait must have a namespace among his parents: " + container; + assert containingPackage != null : "Trait must have a package fragment among his parents: " + container; if (proto.hasExtension(JavaProtoBuf.implClassName)) { Name tImplName = nameResolver.getName(proto.getExtension(JavaProtoBuf.implClassName)); diff --git a/grammar/src/expressions.grm b/grammar/src/expressions.grm index 727a93e6edd..5b4bae7859e 100644 --- a/grammar/src/expressions.grm +++ b/grammar/src/expressions.grm @@ -122,7 +122,7 @@ atomicExpression : loop : SimpleName : FieldName - : "namespace" // for the root namespace + : "package" // for the root package ; label diff --git a/grammar/src/lexical.grm b/grammar/src/lexical.grm index e62dbe96728..1b8a53fc087 100644 --- a/grammar/src/lexical.grm +++ b/grammar/src/lexical.grm @@ -83,7 +83,7 @@ bq. See [Nonlocal returns and jumps] */ /* Keywords: -namespace +package as type class diff --git a/grammar/src/types.grm b/grammar/src/types.grm index 22f9ec521a7..49d15fd10f0 100644 --- a/grammar/src/types.grm +++ b/grammar/src/types.grm @@ -32,7 +32,7 @@ selfType ; userType - : ("namespace" ".")? simpleUserType{"."} + : ("package" ".")? simpleUserType{"."} ; simpleUserType diff --git a/idea/src/org/jetbrains/jet/plugin/debugger/JetPositionManager.java b/idea/src/org/jetbrains/jet/plugin/debugger/JetPositionManager.java index 6994ba9a9da..d03a41eaa30 100644 --- a/idea/src/org/jetbrains/jet/plugin/debugger/JetPositionManager.java +++ b/idea/src/org/jetbrains/jet/plugin/debugger/JetPositionManager.java @@ -186,7 +186,7 @@ public class JetPositionManager implements PositionManager { AnalyzeExhaust analyzeExhaust = AnalyzerFacadeWithCache.analyzeFileWithCache(file); analyzeExhaust.throwIfError(); - Collection namespaceFiles = JetFilesProvider.getInstance(file.getProject()).allNamespaceFiles().fun(file); + Collection namespaceFiles = JetFilesProvider.getInstance(file.getProject()).allPackageFiles().fun(file); DelegatingBindingTrace bindingTrace = new DelegatingBindingTrace(analyzeExhaust.getBindingContext(), "trace created in JetPositionManager"); JetTypeMapper typeMapper = new JetTypeMapper(bindingTrace, ClassBuilderMode.FULL); diff --git a/idea/src/org/jetbrains/jet/plugin/util/DebuggerUtils.java b/idea/src/org/jetbrains/jet/plugin/util/DebuggerUtils.java index 9fdfae58b6d..fdf7e90a592 100644 --- a/idea/src/org/jetbrains/jet/plugin/util/DebuggerUtils.java +++ b/idea/src/org/jetbrains/jet/plugin/util/DebuggerUtils.java @@ -64,7 +64,7 @@ public class DebuggerUtils { return anyFile; } - Collection allNamespaceFiles = filesProvider.allNamespaceFiles().fun(anyFile); + Collection allNamespaceFiles = filesProvider.allPackageFiles().fun(anyFile); JetFile file = PsiCodegenPredictor.getFileForPackagePartName(allNamespaceFiles, className); if (file != null) { return file; diff --git a/js/js.tests/test/org/jetbrains/k2js/test/MultipleFilesTranslationTest.java b/js/js.tests/test/org/jetbrains/k2js/test/MultipleFilesTranslationTest.java index 91d8ca4b438..dabe134af36 100644 --- a/js/js.tests/test/org/jetbrains/k2js/test/MultipleFilesTranslationTest.java +++ b/js/js.tests/test/org/jetbrains/k2js/test/MultipleFilesTranslationTest.java @@ -36,18 +36,20 @@ public abstract class MultipleFilesTranslationTest extends BasicTest { generateJavaScriptFiles(fullFilePaths, dirName, MainCallParameters.noCall(), ecmaVersions); } - protected void runMultiFileTest(@NotNull String dirName, @NotNull String namespaceName, + protected void runMultiFileTest(@NotNull String dirName, @NotNull String packageName, @NotNull String functionName, @NotNull Object expectedResult) throws Exception { - runMultiFileTests(DEFAULT_ECMA_VERSIONS, dirName, namespaceName, functionName, expectedResult); + runMultiFileTests(DEFAULT_ECMA_VERSIONS, dirName, packageName, functionName, expectedResult); } - protected void runMultiFileTests(@NotNull Iterable ecmaVersions, @NotNull String dirName, - @NotNull String namespaceName, + protected void runMultiFileTests( + @NotNull Iterable ecmaVersions, + @NotNull String dirName, + @NotNull String packageName, @NotNull String functionName, - @NotNull Object expectedResult) - throws Exception { + @NotNull Object expectedResult + ) throws Exception { generateJsFromDir(dirName, ecmaVersions); - runRhinoTests(dirName + ".kt", ecmaVersions, new RhinoFunctionResultChecker(namespaceName, functionName, expectedResult)); + runRhinoTests(dirName + ".kt", ecmaVersions, new RhinoFunctionResultChecker(packageName, functionName, expectedResult)); } public void checkFooBoxIsTrue(@NotNull String dirName) throws Exception { diff --git a/js/js.tests/test/org/jetbrains/k2js/test/OutputPrefixPostfixTest.java b/js/js.tests/test/org/jetbrains/k2js/test/OutputPrefixPostfixTest.java index c551d0314d7..ae80151e7f4 100644 --- a/js/js.tests/test/org/jetbrains/k2js/test/OutputPrefixPostfixTest.java +++ b/js/js.tests/test/org/jetbrains/k2js/test/OutputPrefixPostfixTest.java @@ -77,11 +77,11 @@ public final class OutputPrefixPostfixTest extends SingleFileTranslationTest { protected void runFunctionOutputTest( @NotNull Iterable ecmaVersions, @NotNull String kotlinFilename, - @NotNull String namespaceName, + @NotNull String packageName, @NotNull String functionName, @NotNull Object expectedResult ) throws Exception { - super.runFunctionOutputTest(ecmaVersions, kotlinFilename, namespaceName, functionName, expectedResult); + super.runFunctionOutputTest(ecmaVersions, kotlinFilename, packageName, functionName, expectedResult); for (EcmaVersion ecmaVersion : ecmaVersions) { String output = FileUtil.loadFile(new File(getOutputFilePath(filename, ecmaVersion))); diff --git a/js/js.tests/test/org/jetbrains/k2js/test/SingleFileTranslationTest.java b/js/js.tests/test/org/jetbrains/k2js/test/SingleFileTranslationTest.java index 2209fb90949..53b905f1138 100644 --- a/js/js.tests/test/org/jetbrains/k2js/test/SingleFileTranslationTest.java +++ b/js/js.tests/test/org/jetbrains/k2js/test/SingleFileTranslationTest.java @@ -31,17 +31,19 @@ public abstract class SingleFileTranslationTest extends BasicTest { super(main); } - public void runFunctionOutputTest(@NotNull String kotlinFilename, @NotNull String namespaceName, + public void runFunctionOutputTest(@NotNull String kotlinFilename, @NotNull String packageName, @NotNull String functionName, @NotNull Object expectedResult) throws Exception { - runFunctionOutputTest(DEFAULT_ECMA_VERSIONS, kotlinFilename, namespaceName, functionName, expectedResult); + runFunctionOutputTest(DEFAULT_ECMA_VERSIONS, kotlinFilename, packageName, functionName, expectedResult); } - protected void runFunctionOutputTest(@NotNull Iterable ecmaVersions, @NotNull String kotlinFilename, - @NotNull String namespaceName, + protected void runFunctionOutputTest( + @NotNull Iterable ecmaVersions, + @NotNull String kotlinFilename, + @NotNull String packageName, @NotNull String functionName, @NotNull Object expectedResult) throws Exception { generateJavaScriptFiles(kotlinFilename, MainCallParameters.noCall(), ecmaVersions); - runRhinoTests(kotlinFilename, ecmaVersions, new RhinoFunctionResultChecker(namespaceName, functionName, expectedResult)); + runRhinoTests(kotlinFilename, ecmaVersions, new RhinoFunctionResultChecker(packageName, functionName, expectedResult)); } public void checkFooBoxIsTrue(@NotNull String filename, @NotNull Iterable ecmaVersions) throws Exception { diff --git a/js/js.tests/test/org/jetbrains/k2js/test/rhino/RhinoFunctionNativeObjectResultChecker.java b/js/js.tests/test/org/jetbrains/k2js/test/rhino/RhinoFunctionNativeObjectResultChecker.java index 3ecd795694d..0cbd94aff4c 100644 --- a/js/js.tests/test/org/jetbrains/k2js/test/rhino/RhinoFunctionNativeObjectResultChecker.java +++ b/js/js.tests/test/org/jetbrains/k2js/test/rhino/RhinoFunctionNativeObjectResultChecker.java @@ -25,8 +25,8 @@ import org.mozilla.javascript.NativeJavaObject; */ public class RhinoFunctionNativeObjectResultChecker extends RhinoFunctionResultChecker { - public RhinoFunctionNativeObjectResultChecker(@Nullable String namespaceName, String functionName, Object expectedResult) { - super(namespaceName, functionName, expectedResult); + public RhinoFunctionNativeObjectResultChecker(@Nullable String packageName, String functionName, Object expectedResult) { + super(packageName, functionName, expectedResult); } public RhinoFunctionNativeObjectResultChecker(String functionName, Object expectedResult) { diff --git a/js/js.tests/test/org/jetbrains/k2js/test/rhino/RhinoFunctionResultChecker.java b/js/js.tests/test/org/jetbrains/k2js/test/rhino/RhinoFunctionResultChecker.java index ceb90972d6d..227a8e7936b 100644 --- a/js/js.tests/test/org/jetbrains/k2js/test/rhino/RhinoFunctionResultChecker.java +++ b/js/js.tests/test/org/jetbrains/k2js/test/rhino/RhinoFunctionResultChecker.java @@ -28,17 +28,17 @@ import static org.junit.Assert.assertEquals; public class RhinoFunctionResultChecker implements RhinoResultChecker { private final String moduleId; - private final String namespaceName; + private final String packageName; private final String functionName; private final Object expectedResult; - public RhinoFunctionResultChecker(@Nullable String namespaceName, String functionName, Object expectedResult) { - this(Config.REWRITABLE_MODULE_NAME, namespaceName, functionName, expectedResult); + public RhinoFunctionResultChecker(@Nullable String packageName, String functionName, Object expectedResult) { + this(Config.REWRITABLE_MODULE_NAME, packageName, functionName, expectedResult); } - public RhinoFunctionResultChecker(@Nullable String moduleId, @Nullable String namespaceName, String functionName, Object expectedResult) { + public RhinoFunctionResultChecker(@Nullable String moduleId, @Nullable String packageName, String functionName, Object expectedResult) { this.moduleId = moduleId; - this.namespaceName = namespaceName; + this.packageName = packageName; this.functionName = functionName; this.expectedResult = expectedResult; } @@ -56,8 +56,8 @@ public class RhinoFunctionResultChecker implements RhinoResultChecker { protected void assertResultValid(Object result, Context context) { String ecmaVersion = context.getLanguageVersion() == Context.VERSION_1_8 ? "ecma5" : "ecma3"; - assertEquals("Result of " + namespaceName + "." + functionName + "() is not what expected (" + ecmaVersion + ")!", expectedResult, result); - String report = namespaceName + "." + functionName + "() = " + Context.toString(result); + assertEquals("Result of " + packageName + "." + functionName + "() is not what expected (" + ecmaVersion + ")!", expectedResult, result); + String report = packageName + "." + functionName + "() = " + Context.toString(result); System.out.println(report); } @@ -67,15 +67,15 @@ public class RhinoFunctionResultChecker implements RhinoResultChecker { protected String functionCallString() { StringBuilder sb = new StringBuilder(); - if (namespaceName != null) { + if (packageName != null) { sb.append("Kotlin.modules"); if (moduleId.contains(".")) { sb.append("['").append(moduleId).append("']"); } else { sb.append(".").append(moduleId); } - if (namespaceName != Namer.getRootNamespaceName()) { - sb.append('.').append(namespaceName); + if (packageName != Namer.getRootPackageName()) { + sb.append('.').append(packageName); } sb.append('.'); } diff --git a/js/js.tests/test/org/jetbrains/k2js/test/semantics/ExamplesTest.java b/js/js.tests/test/org/jetbrains/k2js/test/semantics/ExamplesTest.java index d416e85a650..b7abf01bc27 100644 --- a/js/js.tests/test/org/jetbrains/k2js/test/semantics/ExamplesTest.java +++ b/js/js.tests/test/org/jetbrains/k2js/test/semantics/ExamplesTest.java @@ -36,7 +36,7 @@ public final class ExamplesTest extends SingleFileTranslationTest { @Override public void runTest() throws Exception { - runFunctionOutputTest(filename, Namer.getRootNamespaceName(), "box", "OK"); + runFunctionOutputTest(filename, Namer.getRootPackageName(), "box", "OK"); } public static Test suite() throws Exception { diff --git a/js/js.tests/test/org/jetbrains/k2js/test/semantics/MiscTest.java b/js/js.tests/test/org/jetbrains/k2js/test/semantics/MiscTest.java index 1f57012d006..8fb87d98bfb 100644 --- a/js/js.tests/test/org/jetbrains/k2js/test/semantics/MiscTest.java +++ b/js/js.tests/test/org/jetbrains/k2js/test/semantics/MiscTest.java @@ -42,7 +42,7 @@ public final class MiscTest extends AbstractExpressionTest { } public void testClassWithoutNamespace() throws Exception { - runFunctionOutputTest("classWithoutNamespace.kt", Namer.getRootNamespaceName(), "box", true); + runFunctionOutputTest("classWithoutNamespace.kt", Namer.getRootPackageName(), "box", true); } public void testIfElseAsExpressionWithThrow() throws Exception { @@ -156,7 +156,7 @@ public final class MiscTest extends AbstractExpressionTest { //TODO: see http://youtrack.jetbrains.com/issue/KT-2564 @SuppressWarnings("UnusedDeclaration") public void TODO_testNamespaceLevelVarInRoot() throws Exception { - runFunctionOutputTest("namespaceLevelVarInRoot.kt", Namer.getRootNamespaceName(), "box", "OK"); + runFunctionOutputTest("namespaceLevelVarInRoot.kt", Namer.getRootPackageName(), "box", "OK"); } public void testLazyPropertyGetterNotCalledOnStart() throws Exception { diff --git a/js/js.translator/src/org/jetbrains/k2js/translate/context/Namer.java b/js/js.translator/src/org/jetbrains/k2js/translate/context/Namer.java index 7b75c0cb915..63a30476a6c 100644 --- a/js/js.translator/src/org/jetbrains/k2js/translate/context/Namer.java +++ b/js/js.translator/src/org/jetbrains/k2js/translate/context/Namer.java @@ -62,7 +62,7 @@ public final class Namer { } @NotNull - public static String getRootNamespaceName() { + public static String getRootPackageName() { return ROOT_PACKAGE; } @@ -257,8 +257,8 @@ public final class Namer { } @NotNull - static String generateNamespaceName(@NotNull FqName packageFqName) { - return packageFqName.isRoot() ? getRootNamespaceName() : packageFqName.shortName().asString(); + static String generatePackageName(@NotNull FqName packageFqName) { + return packageFqName.isRoot() ? getRootPackageName() : packageFqName.shortName().asString(); } @NotNull diff --git a/js/js.translator/src/org/jetbrains/k2js/translate/context/StaticContext.java b/js/js.translator/src/org/jetbrains/k2js/translate/context/StaticContext.java index 9c22a2da29e..04f776bd83d 100644 --- a/js/js.translator/src/org/jetbrains/k2js/translate/context/StaticContext.java +++ b/js/js.translator/src/org/jetbrains/k2js/translate/context/StaticContext.java @@ -188,7 +188,7 @@ public final class StaticContext { return ContainerUtil.getOrCreate(packageNames, packageFqName, new Factory() { @Override public JsName create() { - String name = Namer.generateNamespaceName(packageFqName); + String name = Namer.generatePackageName(packageFqName); return getRootScope().declareName(name); } }); @@ -412,7 +412,7 @@ public final class StaticContext { if (!(descriptor instanceof PackageFragmentDescriptor)) { return null; } - return getRootScope().innerScope("Namespace " + descriptor.getName()); + return getRootScope().innerScope("Package " + descriptor.getName()); } }; //TODO: never get there @@ -465,7 +465,7 @@ public final class StaticContext { } }; //TODO: review and refactor - Rule packageLevelDeclarationsHaveEnclosingNamespacesNamesAsQualifier = new Rule() { + Rule packageLevelDeclarationsHaveEnclosingPackagesNamesAsQualifier = new Rule() { @Override public JsNameRef apply(@NotNull DeclarationDescriptor descriptor) { DeclarationDescriptor containingDescriptor = getContainingDeclaration(descriptor); @@ -525,7 +525,7 @@ public final class StaticContext { addRule(libraryObjectsHaveKotlinQualifier); addRule(constructorHaveTheSameQualifierAsTheClass); addRule(standardObjectsHaveKotlinQualifier); - addRule(packageLevelDeclarationsHaveEnclosingNamespacesNamesAsQualifier); + addRule(packageLevelDeclarationsHaveEnclosingPackagesNamesAsQualifier); } } diff --git a/js/js.translator/src/org/jetbrains/k2js/translate/declaration/NamespaceDeclarationTranslator.java b/js/js.translator/src/org/jetbrains/k2js/translate/declaration/PackageDeclarationTranslator.java similarity index 80% rename from js/js.translator/src/org/jetbrains/k2js/translate/declaration/NamespaceDeclarationTranslator.java rename to js/js.translator/src/org/jetbrains/k2js/translate/declaration/PackageDeclarationTranslator.java index 429d6d3bda8..01bb598b510 100644 --- a/js/js.translator/src/org/jetbrains/k2js/translate/declaration/NamespaceDeclarationTranslator.java +++ b/js/js.translator/src/org/jetbrains/k2js/translate/declaration/PackageDeclarationTranslator.java @@ -32,16 +32,16 @@ import java.util.*; import static com.google.dart.compiler.backend.js.ast.JsVars.JsVar; import static org.jetbrains.k2js.translate.declaration.DefineInvocation.createDefineInvocation; -public final class NamespaceDeclarationTranslator extends AbstractTranslator { +public final class PackageDeclarationTranslator extends AbstractTranslator { private final Iterable files; - private final Map packageFragmentToTranslator = - new LinkedHashMap(); + private final Map packageFragmentToTranslator = + new LinkedHashMap(); public static List translateFiles(@NotNull Collection files, @NotNull TranslationContext context) { - return new NamespaceDeclarationTranslator(files, context).translate(); + return new PackageDeclarationTranslator(files, context).translate(); } - private NamespaceDeclarationTranslator(@NotNull Iterable files, @NotNull TranslationContext context) { + private PackageDeclarationTranslator(@NotNull Iterable files, @NotNull TranslationContext context) { super(context); this.files = files; @@ -55,17 +55,17 @@ public final class NamespaceDeclarationTranslator extends AbstractTranslator { for (JetFile file : files) { PackageFragmentDescriptor packageFragment = context().bindingContext().get(BindingContext.FILE_TO_PACKAGE_FRAGMENT, file); - NamespaceTranslator translator = packageFragmentToTranslator.get(packageFragment); + PackageTranslator translator = packageFragmentToTranslator.get(packageFragment); if (translator == null) { createRootPackageDefineInvocationIfNeeded(packageFqNameToDefineInvocation); - translator = new NamespaceTranslator(packageFragment, packageFqNameToDefineInvocation, context()); + translator = new PackageTranslator(packageFragment, packageFqNameToDefineInvocation, context()); packageFragmentToTranslator.put(packageFragment, translator); } translator.translate(file); } - for (NamespaceTranslator translator : packageFragmentToTranslator.values()) { + for (PackageTranslator translator : packageFragmentToTranslator.values()) { translator.add(packageFqNameToDefineInvocation); } @@ -84,6 +84,6 @@ public final class NamespaceDeclarationTranslator extends AbstractTranslator { private JsVar getRootPackageDeclaration(@NotNull DefineInvocation defineInvocation) { JsExpression rootPackageVar = new JsInvocation(context().namer().rootPackageDefinitionMethodReference(), defineInvocation.asList()); - return new JsVar(context().scope().declareName(Namer.getRootNamespaceName()), rootPackageVar); + return new JsVar(context().scope().declareName(Namer.getRootPackageName()), rootPackageVar); } } diff --git a/js/js.translator/src/org/jetbrains/k2js/translate/declaration/NamespaceTranslator.java b/js/js.translator/src/org/jetbrains/k2js/translate/declaration/PackageTranslator.java similarity index 98% rename from js/js.translator/src/org/jetbrains/k2js/translate/declaration/NamespaceTranslator.java rename to js/js.translator/src/org/jetbrains/k2js/translate/declaration/PackageTranslator.java index 031b89ed9a4..355e58b6480 100644 --- a/js/js.translator/src/org/jetbrains/k2js/translate/declaration/NamespaceTranslator.java +++ b/js/js.translator/src/org/jetbrains/k2js/translate/declaration/PackageTranslator.java @@ -37,7 +37,7 @@ import java.util.Map; import static org.jetbrains.k2js.translate.declaration.DefineInvocation.createDefineInvocation; import static org.jetbrains.k2js.translate.expression.LiteralFunctionTranslator.createPlace; -final class NamespaceTranslator extends AbstractTranslator { +final class PackageTranslator extends AbstractTranslator { @NotNull private final PackageFragmentDescriptor descriptor; @@ -45,7 +45,7 @@ final class NamespaceTranslator extends AbstractTranslator { private final NotNullLazyValue, LabelGenerator, JsExpression>> definitionPlace; - NamespaceTranslator( + PackageTranslator( @NotNull final PackageFragmentDescriptor descriptor, @NotNull final Map packageFqNameToDefineInvocation, @NotNull TranslationContext context diff --git a/js/js.translator/src/org/jetbrains/k2js/translate/general/Translation.java b/js/js.translator/src/org/jetbrains/k2js/translate/general/Translation.java index d32e2c90c21..6b06f40062a 100644 --- a/js/js.translator/src/org/jetbrains/k2js/translate/general/Translation.java +++ b/js/js.translator/src/org/jetbrains/k2js/translate/general/Translation.java @@ -34,7 +34,7 @@ import org.jetbrains.k2js.facade.exceptions.UnsupportedFeatureException; import org.jetbrains.k2js.translate.context.Namer; import org.jetbrains.k2js.translate.context.StaticContext; import org.jetbrains.k2js.translate.context.TranslationContext; -import org.jetbrains.k2js.translate.declaration.NamespaceDeclarationTranslator; +import org.jetbrains.k2js.translate.declaration.PackageDeclarationTranslator; import org.jetbrains.k2js.translate.expression.ExpressionVisitor; import org.jetbrains.k2js.translate.expression.FunctionTranslator; import org.jetbrains.k2js.translate.expression.PatternTranslator; @@ -135,7 +135,7 @@ public final class Translation { TranslationContext context = TranslationContext.rootContext(staticContext, rootFunction); staticContext.initTranslators(context); - statements.addAll(NamespaceDeclarationTranslator.translateFiles(files, context)); + statements.addAll(PackageDeclarationTranslator.translateFiles(files, context)); defineModule(context, statements, config.getModuleId()); if (mainCallParameters.shouldBeGenerated()) { @@ -149,10 +149,10 @@ public final class Translation { } private static void defineModule(@NotNull TranslationContext context, @NotNull List statements, @NotNull String moduleId) { - JsName rootNamespaceName = context.scope().findName(Namer.getRootNamespaceName()); - if (rootNamespaceName != null) { + JsName rootPackageName = context.scope().findName(Namer.getRootPackageName()); + if (rootPackageName != null) { statements.add(new JsInvocation(context.namer().kotlin("defineModule"), context.program().getStringLiteral(moduleId), - rootNamespaceName.makeRef()).makeStmt()); + rootPackageName.makeRef()).makeStmt()); } } diff --git a/js/js.translator/src/org/jetbrains/k2js/translate/utils/JsAstUtils.java b/js/js.translator/src/org/jetbrains/k2js/translate/utils/JsAstUtils.java index 846a2b21dad..5e6d31907df 100644 --- a/js/js.translator/src/org/jetbrains/k2js/translate/utils/JsAstUtils.java +++ b/js/js.translator/src/org/jetbrains/k2js/translate/utils/JsAstUtils.java @@ -20,11 +20,6 @@ import com.google.dart.compiler.backend.js.ast.*; import com.intellij.util.SmartList; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; -import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; -import org.jetbrains.jet.lang.descriptors.Modality; -import org.jetbrains.jet.lang.descriptors.PropertyDescriptor; -import org.jetbrains.jet.lang.psi.JetElement; import org.jetbrains.k2js.translate.context.Namer; import org.jetbrains.k2js.translate.context.TranslationContext; @@ -252,7 +247,7 @@ public final class JsAstUtils { JsExpression parent = qualifier.getQualifier(); assert parent instanceof JsNameRef : "unexpected qualifier: " + parent + ", original: " + fullQualifier; if (((JsNameRef) parent).getQualifier() == null) { - assert Namer.getRootNamespaceName().equals(((JsNameRef) parent).getIdent()); + assert Namer.getRootPackageName().equals(((JsNameRef) parent).getIdent()); qualifier.setQualifier(newQualifier); return; }