Make ClassId's relative class name FqName instead of FqNameUnsafe

It was FqNameUnsafe in times when there were classes without identifier names,
specifically class objects with names like '<class-object-for-...>'

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegenUtil.java

@@ -37,7 +37,7 @@ import org.jetbrains.kotlin.load.kotlin.PackageClassUtils;
 import org.jetbrains.kotlin.load.kotlin.PackagePartClassUtils;
 import org.jetbrains.kotlin.load.kotlin.VirtualFileFinder;
 import org.jetbrains.kotlin.name.ClassId;
-import org.jetbrains.kotlin.name.FqNameUnsafe;
+import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.JetFile;
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils;
@@ -150,7 +150,7 @@ public class InlineCodegenUtil {
     @NotNull
     public static VirtualFile getVirtualFileForCallable(@NotNull ClassId containerClassId, @NotNull GenerationState state) {
         VirtualFileFinder fileFinder = VirtualFileFinder.SERVICE.getInstance(state.getProject());
-        VirtualFile file = fileFinder.findVirtualFileWithHeader(containerClassId.asSingleFqName().toSafe());
+        VirtualFile file = fileFinder.findVirtualFileWithHeader(containerClassId.asSingleFqName());
         if (file == null) {
             throw new IllegalStateException("Couldn't find declaration file for " + containerClassId);
         }
@@ -193,7 +193,7 @@ public class InlineCodegenUtil {
         if (containerDescriptor instanceof ClassDescriptor) {
             ClassId classId = DescriptorUtilPackage.getClassId((ClassDescriptor) containerDescriptor);
             if (isTrait(containerDescriptor)) {
-                FqNameUnsafe relativeClassName = classId.getRelativeClassName();
+                FqName relativeClassName = classId.getRelativeClassName();
                 //TODO test nested trait fun inlining
                 classId = new ClassId(classId.getPackageFqName(), Name.identifier(relativeClassName.shortName().asString() + JvmAbi.TRAIT_IMPL_SUFFIX));
             }

compiler/frontend.java/src/org/jetbrains/kotlin/load/java/JavaClassFinderImpl.java

@@ -31,7 +31,6 @@ import org.jetbrains.kotlin.load.java.structure.impl.JavaClassImpl;
 import org.jetbrains.kotlin.load.java.structure.impl.JavaPackageImpl;
 import org.jetbrains.kotlin.name.ClassId;
 import org.jetbrains.kotlin.name.FqName;
-import org.jetbrains.kotlin.name.FqNameUnsafe;
 import org.jetbrains.kotlin.resolve.jvm.JavaClassFinderPostConstruct;
 import org.jetbrains.kotlin.resolve.jvm.KotlinJavaPsiFacade;
 
@@ -87,14 +86,14 @@ public class JavaClassFinderImpl implements JavaClassFinder {
     @Nullable
     @Override
     public JavaClass findClass(@NotNull ClassId classId) {
-        FqNameUnsafe fqName = classId.asSingleFqName();
+        FqName fqName = classId.asSingleFqName();
 
         PsiClass psiClass = javaFacade.findClass(fqName.asString(), javaSearchScope);
         if (psiClass == null) return null;
 
         JavaClassImpl javaClass = new JavaClassImpl(psiClass);
 
-        if (!fqName.equalsTo(javaClass.getFqName())) {
+        if (!fqName.equals(javaClass.getFqName())) {
             throw new IllegalStateException("Requested " + fqName + ", got " + javaClass.getFqName());
         }
 

compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/FileBasedKotlinClass.java

@@ -25,7 +25,6 @@ import org.jetbrains.kotlin.load.kotlin.header.KotlinClassHeader;
 import org.jetbrains.kotlin.load.kotlin.header.ReadKotlinClassHeaderAnnotationVisitor;
 import org.jetbrains.kotlin.name.ClassId;
 import org.jetbrains.kotlin.name.FqName;
-import org.jetbrains.kotlin.name.FqNameUnsafe;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.org.objectweb.asm.ClassReader;
 import org.jetbrains.org.objectweb.asm.ClassVisitor;
@@ -288,7 +287,7 @@ public abstract class FileBasedKotlinClass implements KotlinJvmBinaryClass {
         Collections.reverse(classes);
 
         FqName packageFqName = outermostClassFqName.parent();
-        FqNameUnsafe relativeClassName = FqNameUnsafe.fromSegments(classes);
+        FqName relativeClassName = FqName.fromSegments(classes);
         return new ClassId(packageFqName, relativeClassName, local);
     }
 

compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/VirtualFileKotlinClassFinder.kt

@@ -18,12 +18,12 @@ package org.jetbrains.kotlin.load.kotlin
 
 import org.jetbrains.kotlin.load.java.structure.JavaClass
 import org.jetbrains.kotlin.load.java.structure.impl.JavaClassImpl
-import org.jetbrains.kotlin.utils.sure
 import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.utils.sure
 
 public abstract class VirtualFileKotlinClassFinder : VirtualFileFinder {
     override fun findKotlinClass(classId: ClassId): KotlinJvmBinaryClass? {
-        val file = findVirtualFileWithHeader(classId.asSingleFqName().toSafe()) ?: return null
+        val file = findVirtualFileWithHeader(classId.asSingleFqName()) ?: return null
         return KotlinBinaryClassCache.getKotlinBinaryClass(file)
     }
 

compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeResolver.kt

@@ -16,27 +16,31 @@
 
 package org.jetbrains.kotlin.resolve
 
-import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.context.TypeLazinessToken
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.descriptors.ClassifierDescriptor
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
+import org.jetbrains.kotlin.diagnostics.Errors.*
 import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.psi.codeFragmentUtil.debugTypeInfo
+import org.jetbrains.kotlin.psi.debugText.getDebugText
+import org.jetbrains.kotlin.resolve.PossiblyBareType.type
+import org.jetbrains.kotlin.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider
+import org.jetbrains.kotlin.resolve.lazy.ForceResolveUtil
+import org.jetbrains.kotlin.resolve.lazy.LazyEntity
 import org.jetbrains.kotlin.resolve.scopes.JetScope
 import org.jetbrains.kotlin.resolve.scopes.LazyScopeAdapter
-import org.jetbrains.kotlin.types.*
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.storage.LockBasedStorageManager
-
-import org.jetbrains.kotlin.diagnostics.Errors.*
-import org.jetbrains.kotlin.resolve.PossiblyBareType.type
-import org.jetbrains.kotlin.types.Variance.*
-import org.jetbrains.kotlin.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider
-import kotlin.platform.platformStatic
 import org.jetbrains.kotlin.storage.StorageManager
-import org.jetbrains.kotlin.context.TypeLazinessToken
-import org.jetbrains.kotlin.resolve.lazy.LazyEntity
-import org.jetbrains.kotlin.resolve.lazy.ForceResolveUtil
+import org.jetbrains.kotlin.types.*
+import org.jetbrains.kotlin.types.Variance.INVARIANT
+import org.jetbrains.kotlin.types.Variance.IN_VARIANCE
+import org.jetbrains.kotlin.types.Variance.OUT_VARIANCE
 import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
-import org.jetbrains.kotlin.psi.debugText.getDebugText
-import org.jetbrains.kotlin.psi.codeFragmentUtil.debugTypeInfo
+import kotlin.platform.platformStatic
 
 public class TypeResolver(
         private val annotationResolver: AnnotationResolver,
@@ -175,7 +179,7 @@ public class TypeResolver(
                                 result = type(ErrorUtils.createErrorTypeWithArguments("" + typeConstructor, arguments))
                             }
                             else {
-                                if (Flexibility.FLEXIBLE_TYPE_CLASSIFIER.asSingleFqName() == DescriptorUtils.getFqName(classifierDescriptor)
+                                if (Flexibility.FLEXIBLE_TYPE_CLASSIFIER.asSingleFqName().toUnsafe() == DescriptorUtils.getFqName(classifierDescriptor)
                                     && classifierDescriptor.getTypeConstructor().getParameters().size() == 2) {
                                     // We create flexible types by convention here
                                     // This is not intended to be used in normal users' environments, only for tests and debugger etc