mbien commented on code in PR #8197:
URL: https://github.com/apache/netbeans/pull/8197#discussion_r1935037771


##########
java/refactoring.java/src/org/netbeans/modules/refactoring/java/plugins/InnerToOuterTransformer.java:
##########
@@ -582,44 +586,79 @@ private ClassTree refactorInnerClass(ClassTree 
innerClass) {
         }
         rewrite(modifiersTree, newModifiersTree);
 
+        // create constructor which refers with member to old outer.
         if (referenceName != null) {
             for (Tree member:newInnerClass.getMembers()) {
                 if (member.getKind() == Tree.Kind.METHOD) {
-                    MethodTree m = (MethodTree) member;
-                    if (m.getName().contentEquals("<init>") || 
m.getReturnType() == null) {
-                        VariableTree parameter = 
make.Variable(make.Modifiers(EnumSet.of(Modifier.FINAL)), 
refactoring.getReferenceName(), make.Type(outerType), null);
-                        MethodTree newConstructor = hasVarArgs(m) ?
-                            make.insertMethodParameter(m, 
m.getParameters().size() - 1, parameter) : 
-                            make.addMethodParameter(m, parameter);
-                        
+                    MethodTree ctor = (MethodTree) member;
+                    if (ctor.getName().contentEquals("<init>") || 
ctor.getReturnType() == null) {
+                        VariableTree parameter = 
make.Variable(make.Modifiers(EnumSet.of(Modifier.FINAL)), referenceName, 
make.Type(outerType), null);
+                        MethodTree newConstructor = hasVarArgs(ctor) ?
+                            make.insertMethodParameter(ctor, 
ctor.getParameters().size() - 1, parameter) :
+                            make.addMethodParameter(ctor, parameter);
+
                         AssignmentTree assign = 
make.Assignment(make.Identifier("this."+referenceName), 
make.Identifier(referenceName)); // NOI18N
                         BlockTree block = 
make.insertBlockStatement(newConstructor.getBody(), 1, 
make.ExpressionStatement(assign));
                         Set<Modifier> modifiers = 
EnumSet.noneOf(Modifier.class);
                         
modifiers.addAll(newConstructor.getModifiers().getFlags());
                         modifiers.remove(Modifier.PRIVATE);
                         newConstructor = make.Constructor(
                                 
make.Modifiers(modifiers,newConstructor.getModifiers().getAnnotations()),
-                                newConstructor.getTypeParameters(), 
+                                newConstructor.getTypeParameters(),
                                 newConstructor.getParameters(),
                                 newConstructor.getThrows(),
                                 block);
 
-                        newInnerClass = make.removeClassMember(newInnerClass, 
m);
-                        genUtils.copyComments(m, newConstructor, true);
-                        genUtils.copyComments(m, newConstructor, false);
+                        newInnerClass = make.removeClassMember(newInnerClass, 
ctor);
+                        genUtils.copyComments(ctor, newConstructor, true);
+                        genUtils.copyComments(ctor, newConstructor, false);
                         newInnerClass = 
genUtils.insertClassMember(newInnerClass, newConstructor);
                     }
                 }
             }
         }
-        
+
         if(innerClass != newInnerClass) {
             genUtils.copyComments(innerClass, newInnerClass, true);
             genUtils.copyComments(innerClass, newInnerClass, false);
         }
         return newInnerClass;
     }
 
+    private ClassTree refactorInnerRecord(ClassTree innerRecord) {
+        refactoring.setInnerIsRecord(true);
+        ClassTree newInnerRecord = innerRecord;
+        List<? extends Tree> members = newInnerRecord.getMembers();
+        int insertAt=0;
+        for (Tree member : members) {
+            Tree.Kind kind = member.getKind();
+//            System.out.println("member = " + kind + "" + member);
+            
+            switch (kind) {
+               // The fields, except the static, should loose private final 
modifiers
+               // so that they appear without these modifiers in the record 
header
+                case VARIABLE:
+                    VariableTree vt = (VariableTree) member;
+                    ModifiersTree mt = vt.getModifiers();
+                    if (mt.getFlags().contains(Modifier.STATIC)) {
+                        continue;
+                    }
+                    Tree mtype = vt.getType();
+                    Name mName = vt.getName();
+                    ModifiersTree mods = 
make.Modifiers(EnumSet.noneOf(Modifier.class));
+                    VariableTree newMember = make.RecordComponent(mods, mName, 
mtype);
+                    newInnerRecord = make.removeClassMember(newInnerRecord, 
member);
+                    newInnerRecord = make.insertClassMember(newInnerRecord, 
insertAt, newMember);
+                    insertAt++;
+                    break;
+                default:
+            }
+
+//            if (member.getKind())

Review Comment:
   looks like this can be removed



-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: [email protected]

For queries about this service, please contact Infrastructure at:
[email protected]


---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]

For further information about the NetBeans mailing lists, visit:
https://cwiki.apache.org/confluence/display/NETBEANS/Mailing+lists

Reply via email to