/**
 * Compute all the types referenced in the signature of this type.
 *
 * @return
 */
public List<String> getTypesInSignature() {
	if (dimensions > 0) {
		return Collections.emptyList();
	} else if (node.signature == null) {
		// With no generic signature it is just superclass and interfaces
		List<String> ls = new ArrayList<>();
		if (node.superName != null) {
			ls.add(node.superName);
		}
		if (node.interfaces != null) {
			ls.addAll(node.interfaces);
		}
		return ls;
	} else {
		// Pull out all the types from the generic signature
		SignatureReader reader = new SignatureReader(node.signature);
		TypeCollector tc = new TypeCollector();
		reader.accept(tc);
		return tc.getTypes();
	}
}
 

/**
 * Appends the Java generic type declaration corresponding to the given signature.
 *
 * @param name a class, field or method name.
 * @param signature a class, field or method signature.
 */
private void appendJavaDeclaration(final String name, final String signature) {
  TraceSignatureVisitor traceSignatureVisitor = new TraceSignatureVisitor(access);
  new SignatureReader(signature).accept(traceSignatureVisitor);
  stringBuilder.append("// declaration: ");
  if (traceSignatureVisitor.getReturnType() != null) {
    stringBuilder.append(traceSignatureVisitor.getReturnType());
    stringBuilder.append(' ');
  }
  stringBuilder.append(name);
  stringBuilder.append(traceSignatureVisitor.getDeclaration());
  if (traceSignatureVisitor.getExceptions() != null) {
    stringBuilder.append(" throws ").append(traceSignatureVisitor.getExceptions());
  }
  stringBuilder.append('\n');
}
 

@Override
public FieldVisitor visitField(final int access, final String name, final String desc, final String signature, final Object value) {
  if (Visibility.get(access) == Visibility.PRIVATE || FingerprintUtil.isSynthetic(access))
    return null;

  final FieldVisitor fieldVisitor = super.visitField(access, name, desc, signature, value);
  final Type type = Type.getType(desc);
  if (filtering)
    return null;

  addClassRef(type);
  final FieldLog log = addFieldRef(Type.getObjectType(className), name);
  if (log == null)
    return null;

  if (signature != null)
    new SignatureReader(signature).accept(signatureVisitor);

  log.resolve(typeToClassName(type, false));
  return fieldVisitor;
}
 

private FieldType typeDescriptorToFieldType(String descriptor, String signature) {
    if (signature == null) {
        return typeDescriptorToFieldType(descriptor);
    }

    ArrayList<TypeIdentifier> typeParameters = new ArrayList<>();
    new SignatureReader(signature).accept(
            new SignatureVisitor(this.api) {
                @Override
                public SignatureVisitor visitTypeArgument(char wildcard) {
                    if (wildcard == '=') {
                        return new SignatureVisitor(this.api) {
                            @Override
                            public void visitClassType(String name) {
                                typeParameters.add(new TypeIdentifier(name));
                            }
                        };
                    }
                    return super.visitTypeArgument(wildcard);
                }
            }
    );
    TypeIdentifiers typeIdentifiers = new TypeIdentifiers(typeParameters);
    return new FieldType(typeDescriptorToIdentifier(descriptor), typeIdentifiers);
}
 

private List<TypeIdentifier> extractClassTypeFromGenericsSignature(String signature) {
    // ジェネリクスを使用している場合だけsignatureが入る
    List<TypeIdentifier> useTypes = new ArrayList<>();
    if (signature != null) {
        new SignatureReader(signature).accept(
                new SignatureVisitor(this.api) {
                    @Override
                    public void visitClassType(String name) {
                        // 引数と戻り値に登場するクラスを収集
                        useTypes.add(new TypeIdentifier(name));
                    }
                }
        );
    }
    return useTypes;
}
 

@Override
public MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions) {

    if (signature == null) {
        dependencyCollector.addMethodDescriptor(descriptor);
    } else {
        new SignatureReader(signature).accept(signatureVisitor);
    }

    if (exceptions != null) {
        for (String ex : exceptions)
            dependencyCollector.addType(ex);
    }

    MethodVisitor mv = super.visitMethod(access, name, descriptor, signature, exceptions);
    return new MethodDependencyVisitor(mv, signatureVisitor, dependencyCollector, preserveDebugInfo);
}
 

@Override
public void visitLocalVariable(final String name, final String desc, final String signature, final Label start, final Label end, final int index) {
  buf.setLength(0);
  buf.append(tab2).append("LOCALVARIABLE ").append(name).append(' ');
  appendDescriptor(FIELD_DESCRIPTOR, desc);
  buf.append(' ');
  appendLabel(start);
  buf.append(' ');
  appendLabel(end);
  buf.append(' ').append(index).append('\n');

  if (signature != null) {
    buf.append(tab2);
    appendDescriptor(FIELD_SIGNATURE, signature);

    TraceSignatureVisitor sv = new TraceSignatureVisitor(0);
    SignatureReader r = new SignatureReader(signature);
    r.acceptType(sv);
    buf.append(tab2).append("// declaration: ").append(sv.getDeclaration()).append('\n');
  }
  text.add(buf.toString());
}
 

FieldAnalyzeVisitor parseSignature() {
  final EntryMessage m = log.traceEntry("fieldSignature={}", fieldSignature);
  boolean isStatic = (Opcodes.ACC_STATIC & this.access) > 0;
  SignatureReader signatureReader = new SignatureReader(this.fieldSignature);
  FieldSignatureVisitor visitor;
  if (isStatic) {
    visitor = new FieldSignatureVisitor(this.name, new ArrayList<>(4));
  } else {
    visitor = new FieldSignatureVisitor(this.name, this.classAnalyzeVisitor.classTypeParameters);
  }
  if (this.typeMap != null) {
    visitor.setTypeMap(this.typeMap);
  }

  this.fieldSignatureVisitor = visitor;
  signatureReader.acceptType(fieldSignatureVisitor);
  return log.traceExit(m, this);
}
 

MethodAnalyzeVisitor parseSignature() {
  final EntryMessage entryMessage =
      log.traceEntry("name={} methodSignature={}", this.name, this.methodSignature);
  final boolean isStatic = (Opcodes.ACC_STATIC & this.access) > 0;
  final SignatureReader signatureReader = new SignatureReader(this.methodSignature);
  MethodSignatureVisitor visitor;
  if (isStatic) {
    visitor = new MethodSignatureVisitor(this.name, new ArrayList<>(4));
  } else {
    visitor = new MethodSignatureVisitor(this.name, this.classAnalyzeVisitor.classTypeParameters);
  }
  if (this.typeMap != null) {
    visitor.setTypeMap(this.typeMap);
  }

  signatureReader.accept(visitor);

  this.formalType = visitor.getFormalType();
  this.parameterTypes = visitor.getParameterTypes();
  this.typeParameters = visitor.getTypeParameters();
  this.returnType = visitor.getReturnType();
  log.traceExit(entryMessage);
  return this;
}
 

@Override
public MethodVisitor visitMethod(
    int access, String name, String desc, String signature, String[] exceptions) {

  String target = signature;
  if (target == null) {
    target = desc;
  }
  SignatureReader signatureReader = new SignatureReader(target);
  this.visitor = new MethodSignatureVisitor(name, new ArrayList<>());
  signatureReader.accept(this.visitor);

  System.out.println(name);
  System.out.println(this.visitor.getFormalType());
  System.out.println(this.visitor.getParameterTypes());
  System.out.println(this.visitor.getTypeParameters());
  System.out.println(this.visitor.getReturnType());

  // result.put(name, this.visitor.getFormalType());

  return super.visitMethod(access, name, desc, signature, exceptions);
}
 

/**
 * Appends the Java generic type declaration corresponding to the given signature.
 *
 * @param name a class, field or method name.
 * @param signature a class, field or method signature.
 */
private void appendJavaDeclaration(final String name, final String signature) {
  TraceSignatureVisitor traceSignatureVisitor = new TraceSignatureVisitor(access);
  new SignatureReader(signature).accept(traceSignatureVisitor);
  stringBuilder.append("// declaration: ");
  if (traceSignatureVisitor.getReturnType() != null) {
    stringBuilder.append(traceSignatureVisitor.getReturnType());
    stringBuilder.append(' ');
  }
  stringBuilder.append(name);
  stringBuilder.append(traceSignatureVisitor.getDeclaration());
  if (traceSignatureVisitor.getExceptions() != null) {
    stringBuilder.append(" throws ").append(traceSignatureVisitor.getExceptions());
  }
  stringBuilder.append('\n');
}
 

/**
 * Appends the Java generic type declaration corresponding to the given signature.
 *
 * @param name a class, field or method name.
 * @param signature a class, field or method signature.
 */
private void appendJavaDeclaration(final String name, final String signature) {
  TraceSignatureVisitor traceSignatureVisitor = new TraceSignatureVisitor(access);
  new SignatureReader(signature).accept(traceSignatureVisitor);
  stringBuilder.append("// declaration: ");
  if (traceSignatureVisitor.getReturnType() != null) {
    stringBuilder.append(traceSignatureVisitor.getReturnType());
    stringBuilder.append(' ');
  }
  stringBuilder.append(name);
  stringBuilder.append(traceSignatureVisitor.getDeclaration());
  if (traceSignatureVisitor.getExceptions() != null) {
    stringBuilder.append(" throws ").append(traceSignatureVisitor.getExceptions());
  }
  stringBuilder.append('\n');
}
 

private String translateSignature(final String signature, boolean type) {
	if (signature == null) {
		return null;
	}
	SignatureReader r = new SignatureReader(signature);
	SignatureWriter w = new SignatureWriter() {
	    public void visitClassType(final String name) {
	    	String n = translator.getClassMirrorTranslation(name);
	    	super.visitClassType(n);
	    }
	};

	if (type) {
		r.acceptType(w);		
	} else {
		r.accept(w);		
	}
	return w.toString();
}
 

protected void mergeNewFields(MixinTargetContext mixin) {
    for (FieldNode field : mixin.getFields()) {
        FieldNode target = this.findTargetField(field);
        if (target == null) {
            // This is just a local field, so add it
            this.targetClass.fields.add(field);
            
            if (field.signature != null) {
                if (this.mergeSignatures) {
                    SignatureVisitor sv = mixin.getSignature().getRemapper();
                    new SignatureReader(field.signature).accept(sv);
                    field.signature = sv.toString();
                } else {
                    field.signature = null;
                }
            }
        }
    }
}
 

public List<String> getTypesInSignature() {
	if (node.signature == null) {
		return Collections.emptyList();
	} else {
		SignatureReader reader = new SignatureReader(node.signature);
		TypeCollector tc = new TypeCollector();
		reader.accept(tc);
		return tc.getTypes();
	}
}
 

public String findTypeParameterInSupertype(String supertype, int typeParameterNumber) {
	if (node.signature == null) {
		return null;
	}
	SignatureReader reader = new SignatureReader(node.signature);
	TypeParamFinder tpm = new TypeParamFinder(supertype);
	reader.accept(tpm);
	return tpm.getTypeParameter(typeParameterNumber);
}
 

private void addToDeps(String signature, String desc) {
	if(signature == null) {
		signature = desc;
	}
	final SignatureReader signatureReader = new SignatureReader(signature);
	SignatureVisitor visitor = new MethodSignatureVisitor(this.dependencies);
	signatureReader.accept(visitor);
}
 

/**
 * Returns the given signature, remapped with the {@link SignatureVisitor} returned by {@link
 * #createSignatureRemapper(SignatureVisitor)}.
 *
 * @param signature a <i>JavaTypeSignature</i>, <i>ClassSignature</i> or <i>MethodSignature</i>.
 * @param typeSignature whether the given signature is a <i>JavaTypeSignature</i>.
 * @return signature the given signature, remapped with the {@link SignatureVisitor} returned by
 *     {@link #createSignatureRemapper(SignatureVisitor)}.
 */
public String mapSignature(final String signature, final boolean typeSignature) {
  if (signature == null) {
    return null;
  }
  SignatureReader signatureReader = new SignatureReader(signature);
  SignatureWriter signatureWriter = new SignatureWriter();
  SignatureVisitor signatureRemapper = createSignatureRemapper(signatureWriter);
  if (typeSignature) {
    signatureReader.acceptType(signatureRemapper);
  } else {
    signatureReader.accept(signatureRemapper);
  }
  return signatureWriter.toString();
}
 

@Override
public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
    // Signature may be null if the class is not a generic one, and does not extend or implement generic classes or interfaces.
    if (signature == null) {
        dependencyCollector.addType(superName);
        if (interfaces != null) {
            for (String i : interfaces)
                dependencyCollector.addType(i);
        }
    } else {
        new SignatureReader(signature).accept(signatureVisitor);
    }

    super.visit(version, access, name, signature, superName, interfaces);
}
 

@Override
public FieldVisitor visitField(int access, String name, String descriptor, String signature, Object value) {

    if (signature == null) {
        dependencyCollector.addDescriptor(descriptor);
    } else {
        new SignatureReader(signature).acceptType(signatureVisitor);
    }
    return super.visitField(access, name, descriptor, signature, value);
}
 

@Override
public void visitLocalVariable(String name, String descriptor, String signature, Label start, Label end, int index) {
    if (signature == null) {
        dependencyCollector.addDescriptor(descriptor);
    } else {
        new SignatureReader(signature).acceptType(signatureVisitor);
    }

    if (preserveDebugInfo)
        super.visitLocalVariable(name, descriptor, signature, start, end, index);
}
 

@Override
public Iterator<Directive> iterator() {
    new SignatureReader(this.singature).accept(this);
    final Directives dirs = new Directives().add("args");
    for (final String type : this.types) {
        dirs.add("arg").set("?").attr("type", type).up();
    }
    dirs.up().add("return").set(this.rtype.get()).up();
    return dirs.iterator();
}
 

/**
 * Returns the given signature, remapped with the {@link SignatureVisitor} returned by {@link
 * #createSignatureRemapper(SignatureVisitor)}.
 *
 * @param signature a <i>JavaTypeSignature</i>, <i>ClassSignature</i> or <i>MethodSignature</i>.
 * @param typeSignature whether the given signature is a <i>JavaTypeSignature</i>.
 * @return signature the given signature, remapped with the {@link SignatureVisitor} returned by
 *     {@link #createSignatureRemapper(SignatureVisitor)}.
 */
public String mapSignature(final String signature, final boolean typeSignature) {
  if (signature == null) {
    return null;
  }
  SignatureReader signatureReader = new SignatureReader(signature);
  SignatureWriter signatureWriter = new SignatureWriter();
  SignatureVisitor signatureRemapper = createSignatureRemapper(signatureWriter);
  if (typeSignature) {
    signatureReader.acceptType(signatureRemapper);
  } else {
    signatureReader.accept(signatureRemapper);
  }
  return signatureWriter.toString();
}
 

@Override
public Textifier visitField(final int access, final String name, final String desc, final String signature, final Object value) {
  buf.setLength(0);
  buf.append('\n');
  if ((access & Opcodes.ACC_DEPRECATED) != 0) {
    buf.append(tab).append("// DEPRECATED\n");
  }
  buf.append(tab).append("// access flags 0x").append(Integer.toHexString(access).toUpperCase()).append('\n');
  if (signature != null) {
    buf.append(tab);
    appendDescriptor(FIELD_SIGNATURE, signature);

    TraceSignatureVisitor sv = new TraceSignatureVisitor(0);
    SignatureReader r = new SignatureReader(signature);
    r.acceptType(sv);
    buf.append(tab).append("// declaration: ").append(sv.getDeclaration()).append('\n');
  }

  buf.append(tab);
  appendAccess(access);

  appendDescriptor(FIELD_DESCRIPTOR, desc);
  buf.append(' ').append(name);
  if (value != null) {
    buf.append(" = ");
    if (value instanceof String) {
      buf.append('\"').append(value).append('\"');
    } else {
      buf.append(value);
    }
  }

  buf.append('\n');
  text.add(buf.toString());

  Textifier t = createTextifier();
  text.add(t.getText());
  return t;
}
 

@Override
public void visit(
    int api, int access, String name, String signature, String superClass, String[] interfaces) {
  // log.debug("Name:{}", name);
  // call class
  final boolean isInterface = (Opcodes.ACC_INTERFACE & access) == Opcodes.ACC_INTERFACE;
  // log.debug("name {} sig {} IF:{}", name, signature, isInterface);
  if (signature != null) {
    // generics
    // log.debug("name {} sig {}", name, signature);
    final SignatureReader signatureReader = new SignatureReader(signature);
    ClassSignatureVisitor classSignatureVisitor =
        new ClassSignatureVisitor(this.className, isInterface);
    signatureReader.accept(classSignatureVisitor);

    this.classTypeParameters = classSignatureVisitor.getTypeParameters();
    this.classIndex = classSignatureVisitor.getClassIndex();
    if (!this.classIndex.getSupers().contains(ClassNameUtils.OBJECT_CLASS)) {
      this.classIndex.addSuper(ClassNameUtils.OBJECT_CLASS);
    }
  } else {
    this.classTypeParameters = new ArrayList<>(4);
    final List<String> supers = new ArrayList<>(4);
    if (superClass != null) {
      final String superClassFQCN = ClassNameUtils.replaceSlash(superClass);
      supers.add(superClassFQCN);
    }
    Arrays.stream(interfaces)
        .forEach(interfaceName -> supers.add(ClassNameUtils.replaceSlash(interfaceName)));
    this.classIndex = new ClassIndex(this.className, new ArrayList<>(4), supers);
    this.classIndex.setInterface(isInterface);
  }
}
 

@Override
public FieldVisitor visitField(
    int access, String name, String desc, String signature, Object value) {
  String target = signature;
  if (target == null) {
    target = desc;
  }
  SignatureReader signatureReader = new SignatureReader(target);
  this.visitor = new FieldSignatureVisitor(name, new ArrayList<>());
  signatureReader.acceptType(this.visitor);
  result.put(name, this.visitor.getResult());
  return super.visitField(access, name, desc, signature, value);
}
 

@Override
public void visit(
    int api, int access, String name, String sig, String superClass, String[] exceptions) {
  System.out.println("NAME:" + name);
  System.out.println("SUPER:" + superClass);
  System.out.println("sig:" + sig);
  if (sig != null) {
    boolean isInterface = (Opcodes.ACC_INTERFACE & access) == Opcodes.ACC_INTERFACE;
    SignatureReader signatureReader = new SignatureReader(sig);
    this.visitor = new ClassSignatureVisitor(this.name, isInterface);
    signatureReader.accept(this.visitor);
  }
}
 

@Override
public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
  addClass(name);

  if (signature != null) {
    new SignatureReader(signature).accept(signatureVisitor);
  } else {
    addClass(superName);
    addClasses(interfaces);
  }
}
 

/**
 * Converts the given type signature to a human readable type string.
 * <p>
 * Example: {@code Ljava/util/Map<Ljava/lang/String;Ljava/lang/String;>; -> java.util.Map<java.lang.String, java.lang.String>}
 */
public static String toReadableType(final String type) {
    final SignatureReader reader = new SignatureReader(type);
    final TraceSignatureVisitor visitor = new TraceSignatureVisitor(0);
    reader.acceptType(visitor);
    return visitor.getDeclaration();
}
 

static FieldNode createFieldNode(FieldStub field, AsmReferenceResolver resolver, DecompiledClassNode owner) {
    final ClassNode[] type = {resolver.resolveType(Type.getType(field.desc))};
    if (field.signature != null) {
        new SignatureReader(field.signature).accept(new TypeSignatureParser(resolver) {
            @Override
            void finished(ClassNode result) {
                type[0] = applyErasure(result, type[0]);
            }
        });
    }
    ConstantExpression value = field.value == null ? null : new ConstantExpression(field.value);
    return new FieldNode(field.fieldName, field.accessModifiers, type[0], owner, value);
}