Revert "[Xamarin.Android.Tools.Bytecode] hide nested types (#827)" (#855)

Revert commit 4ef5081.
Fixes: #854
Context: 4ef5081
Context: #826
[As noted][0] in [PR #827][1], there is some "weirdness" with what
appears in the [`InnerClasses` collection][2]. It turns out this is
due to a misunderstanding of what the `InnerClasses` collection
contains.
As per the [docs][2]]:
> If a class has members that are classes or interfaces, its
> `constant_pool` table (and hence its `InnerClasses` attribute) must
> refer to each such member, even if that member is not otherwise
> mentioned by the class.
> **These rules imply that a nested class or interface member will
> have `InnerClasses` information for each enclosing class and for
> each immediate member.**
(Emphasis added.) That is, the `PagedList$Config$Builder$Companion`
class lists *both* its immediate containing type
`PagedList$Config$Builder` and the "parent-parent" containing type
`PagedList$Config` within `InnerClasses`.
The change made in commit 4ef5081 loops through `InnerClasses`,
marking them as `internal`, assuming they are all nested types.
This is causing us to hide *declaring* types when we are trying to
hide *nested* types.
This will require more investigation and the deadline for 16.11 is
~now, so we're just going to revert the original commit.
[0]: #827 (comment)
[1]: #827
[2]: https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.7.6

Author: jpobst

src/Xamarin.Android.Tools.Bytecode/Kotlin/KotlinFixups.cs

@@ -30,7 +30,7 @@ public static void Fixup (IList<ClassFile> classes)
 varclass_metadata=(metadataasKotlinClass);
 
 if(class_metadata!=null){
-FixupClassVisibility(c,class_metadata,classes);
+FixupClassVisibility(c,class_metadata);
 
 if(!c.AccessFlags.IsPubliclyVisible())
 continue;
@@ -62,7 +62,7 @@ public static void Fixup (IList<ClassFile> classes)
 }
 }
 
-staticvoidFixupClassVisibility(ClassFileklass,KotlinClassmetadata,IList<ClassFile>classes)
+staticvoidFixupClassVisibility(ClassFileklass,KotlinClassmetadata)
 {
 // Hide class if it isn't Public/Protected
 if(klass.AccessFlags.IsPubliclyVisible()&&!metadata.Visibility.IsPubliclyVisible()){
@@ -83,33 +83,15 @@ static void FixupClassVisibility (ClassFile klass, KotlinClass metadata, IList<C
 Log.Debug($"Kotlin: Hiding internal class {klass.ThisClass.Name.Value}");
 klass.AccessFlags=SetVisibility(klass.AccessFlags,ClassAccessFlags.Private);
 
-foreach(varicinklass.InnerClasses)
-HideInternalInnerClass(ic,classes);
+foreach(varicinklass.InnerClasses){
+Log.Debug($"Kotlin: Hiding nested internal type {ic.InnerClass.Name.Value}");
+ic.InnerClassAccessFlags=SetVisibility(ic.InnerClassAccessFlags,ClassAccessFlags.Private);
+}
 
 return;
 }
 }
 
-staticvoidHideInternalInnerClass(InnerClassInfoklass,IList<ClassFile>classes)
-{
-varexisting=klass.InnerClassAccessFlags;
-
-klass.InnerClassAccessFlags=SetVisibility(existing,ClassAccessFlags.Private);
-Log.Debug($"Kotlin: Hiding nested internal type {klass.InnerClass.Name.Value}");
-
-// Setting the inner class access flags above doesn't technically do anything, because we output
-// from the inner class's ClassFile, so we need to find that and set it there.
-varkf=classes.FirstOrDefault(c =>c.ThisClass.Name.Value==klass.InnerClass.Name.Value);
-
-if(kf!=null){
-kf.AccessFlags=SetVisibility(kf.AccessFlags,ClassAccessFlags.Private);
-kf.InnerClass.InnerClassAccessFlags=SetVisibility(kf.InnerClass.InnerClassAccessFlags,ClassAccessFlags.Private);
-
-foreach(varinner_classinkf.InnerClasses.Where(c =>c.OuterClass.Name.Value==kf.ThisClass.Name.Value))
-HideInternalInnerClass(inner_class,classes);
-}
-}
-
 // Passing null for 'newVisibility' parameter means 'package-private'
 staticClassAccessFlagsSetVisibility(ClassAccessFlagsexisting,ClassAccessFlags?newVisibility)
 {

tests/Xamarin.Android.Tools.Bytecode-Tests/KotlinFixupsTests.cs

@@ -310,24 +310,5 @@ public void HandleKotlinNameShadowing ()
 Assert.True(klass.Methods.Single(m =>m.Name=="hitCount").AccessFlags.HasFlag(MethodAccessFlags.Public));
 Assert.True(klass.Methods.Single(m =>m.Name=="setType").AccessFlags.HasFlag(MethodAccessFlags.Public));
 }
-
-[Test]
-publicvoidHidePublicInterfaceInInternalClass()
-{
-varklass=LoadClassFile("InternalClassWithNestedInterface.class");
-varinner_interface=LoadClassFile("InternalClassWithNestedInterface$NestedInterface.class");
-varinner_inner_interface=LoadClassFile("InternalClassWithNestedInterface$NestedInterface$DoubleNestedInterface.class");
-
-KotlinFixups.Fixup(new[]{klass,inner_interface,inner_inner_interface});
-
-varoutput=newXmlClassDeclarationBuilder(klass).ToXElement().ToString();
-Assert.True(output.Contains("visibility=\"public\""));
-
-varoutput2=newXmlClassDeclarationBuilder(inner_interface).ToXElement().ToString();
-Assert.True(output2.Contains("visibility=\"private\""));
-
-varoutput3=newXmlClassDeclarationBuilder(inner_inner_interface).ToXElement().ToString();
-Assert.True(output3.Contains("visibility=\"private\""));
-}
 }
 }