org.codehaus.groovy.ast.ClassNode.getUnresolvedSuperClass()方法的使用及代码示例

x33g5p2x  于2022-01-18 转载在 其他  
字(9.6k)|赞(0)|评价(0)|浏览(92)

本文整理了Java中org.codehaus.groovy.ast.ClassNode.getUnresolvedSuperClass()方法的一些代码示例，展示了ClassNode.getUnresolvedSuperClass()的具体用法。这些代码示例主要来源于Github/Stackoverflow/Maven等平台，是从一些精选项目中提取出来的代码，具有较强的参考意义，能在一定程度帮忙到你。ClassNode.getUnresolvedSuperClass()方法的具体详情如下：
包路径：org.codehaus.groovy.ast.ClassNode
类名称：ClassNode
方法名：getUnresolvedSuperClass

ClassNode.getUnresolvedSuperClass介绍

暂无

代码示例

代码示例来源：origin: org.codehaus.groovy/groovy

public ClassNode getUnresolvedSuperClass() {
  return getUnresolvedSuperClass(true);
}

代码示例来源：origin: org.codehaus.groovy/groovy

private static List<ClassNode> getAllUnresolvedSuperClasses(ClassNode actualReceiver) {
  List<ClassNode> superClassNodeList = new LinkedList<>();
  for (ClassNode cn = actualReceiver.getUnresolvedSuperClass(); null != cn && ClassHelper.OBJECT_TYPE != cn; cn = cn.getUnresolvedSuperClass()) {
    superClassNodeList.add(cn);
  }
  return superClassNodeList;
}

代码示例来源：origin: org.codehaus.groovy/groovy

@Override
public ClassNode getUnresolvedSuperClass(boolean useRedirect) {
  lazyInitSupers();
  return super.getUnresolvedSuperClass(useRedirect);
}

代码示例来源：origin: org.codehaus.groovy/groovy

public ClassNode getUnresolvedSuperClass(boolean useRedirect) {
  if (!useRedirect) return superClass;
  if (redirect != null) return redirect().getUnresolvedSuperClass(true);
  lazyClassInit();
  return superClass;
}

代码示例来源：origin: org.codehaus.groovy/groovy

private boolean checkWildcard(ClassNode cn) {
  ClassNode sn = cn.getUnresolvedSuperClass(false);
  if (sn == null) return false;
  GenericsType[] generics = sn.getGenericsTypes();
  if (generics == null) return false;
  boolean error = false;
  for (GenericsType generic : generics) {
    if (generic.isWildcard()) {
      addError("A supertype may not specify a wildcard type", sn);
      error = true;
    }
  }
  return error;
}

代码示例来源：origin: org.codehaus.groovy/groovy

/**
 * @return the ClassNode of the super class of this type
 */
public ClassNode getSuperClass() {
  if (!lazyInitDone && !isResolved()) {
    throw new GroovyBugError("ClassNode#getSuperClass for "+getName()+" called before class resolving");
  }
  ClassNode sn = redirect().getUnresolvedSuperClass();
  if (sn!=null) sn=sn.redirect();
  return sn;
}

代码示例来源：origin: org.codehaus.groovy/groovy

public static String getGenericsSignature(ClassNode node) {
  if (!usesGenericsInClassSignature(node)) return null;
  GenericsType[] genericsTypes = node.getGenericsTypes();
  StringBuilder ret = new StringBuilder(100);
  getGenericsTypeSpec(ret, genericsTypes);
  GenericsType extendsPart = new GenericsType(node.getUnresolvedSuperClass(false));
  writeGenericsBounds(ret, extendsPart, true);
  ClassNode[] interfaces = node.getInterfaces();
  for (int i = 0; i < interfaces.length; i++) {
    GenericsType interfacePart = new GenericsType(interfaces[i]);
    writeGenericsBounds(ret, interfacePart, false);
  }
  return ret.toString();
}

代码示例来源：origin: org.codehaus.groovy/groovy

private static boolean usesGenericsInClassSignature(ClassNode node) {
  if (!node.isUsingGenerics()) return false;
  if (hasGenerics(node)) return true;
  ClassNode sclass = node.getUnresolvedSuperClass(false);
  if (sclass.isUsingGenerics()) return true;
  ClassNode[] interfaces = node.getInterfaces();
  if (interfaces != null) {
    for (int i = 0; i < interfaces.length; i++) {
      if (interfaces[i].isUsingGenerics()) return true;
    }
  }
  return false;
}

代码示例来源：origin: org.codehaus.groovy/groovy

private void replaceExtendsByImplements(final ClassNode cNode) {
  ClassNode superClass = cNode.getUnresolvedSuperClass();
  if (Traits.isTrait(superClass)) {
    // move from super class to interface;
    cNode.setSuperClass(ClassHelper.OBJECT_TYPE);
    cNode.setUnresolvedSuperClass(ClassHelper.OBJECT_TYPE);
    cNode.addInterface(superClass);
    resolveScope(cNode);
  }
}

代码示例来源：origin: org.codehaus.groovy/groovy

ClassNode superClass = next.getUnresolvedSuperClass();
if (superClass != null) {
  next =  correctToGenericsSpecRecurse(updatedGenericsSpec, superClass);

代码示例来源：origin: org.codehaus.groovy/groovy

@Override
public void visitClass(ClassNode node) {
  boolean error = checkWildcard(node);
  if (error) return;
  boolean isAnon = node instanceof InnerClassNode && ((InnerClassNode) node).isAnonymous();
  checkGenericsUsage(node.getUnresolvedSuperClass(false), node.getSuperClass(), isAnon ? true : null);
  ClassNode[] interfaces = node.getInterfaces();
  for (ClassNode anInterface : interfaces) {
    checkGenericsUsage(anInterface, anInterface.redirect());
  }
  node.visitContents(this);
}

代码示例来源：origin: org.codehaus.groovy/groovy

return OBJECT_TYPE;
  } else {
    return clazz.getUnresolvedSuperClass();
return clazz.getUnresolvedSuperClass();

代码示例来源：origin: org.codehaus.groovy/groovy

private void addCovariantMethods(ClassNode classNode, List declaredMethods, Map abstractMethods, Map methodsToAdd, Map oldGenericsSpec) {
  ClassNode sn = classNode.getUnresolvedSuperClass(false);
  if (sn != null) {
    Map genericsSpec = createGenericsSpec(sn, oldGenericsSpec);
    List<MethodNode> classMethods = sn.getMethods();
    // original class causing bridge methods for methods in super class
    storeMissingCovariantMethods(declaredMethods, methodsToAdd, genericsSpec, classMethods);
    // super class causing bridge methods for abstract methods in original class
    if (!abstractMethods.isEmpty()) {
      for (Object classMethod : classMethods) {
        MethodNode method = (MethodNode) classMethod;
        if (method.isStatic()) continue;
        storeMissingCovariantMethods(abstractMethods.values(), method, methodsToAdd, Collections.EMPTY_MAP, true);
      }
    }
    addCovariantMethods(sn.redirect(), declaredMethods, abstractMethods, methodsToAdd, genericsSpec);
  }
  ClassNode[] interfaces = classNode.getInterfaces();
  for (ClassNode anInterface : interfaces) {
    List interfacesMethods = anInterface.getMethods();
    Map genericsSpec = createGenericsSpec(anInterface, oldGenericsSpec);
    storeMissingCovariantMethods(declaredMethods, methodsToAdd, genericsSpec, interfacesMethods);
    addCovariantMethods(anInterface, declaredMethods, abstractMethods, methodsToAdd, genericsSpec);
  }
}

代码示例来源：origin: org.codehaus.groovy/groovy

/**
 * @param node the node to be tested
 * @return true if the node is using generics types and one of those types is a gstring or string/gstring lub
 */
public static boolean isParameterizedWithGStringOrGStringString(ClassNode node) {
  if (node.isArray()) return isParameterizedWithGStringOrGStringString(node.getComponentType());
  if (node.isUsingGenerics()) {
    GenericsType[] genericsTypes = node.getGenericsTypes();
    if (genericsTypes != null) {
      for (GenericsType genericsType : genericsTypes) {
        if (isGStringOrGStringStringLUB(genericsType.getType())) return true;
      }
    }
  }
  return node.getSuperClass() != null && isParameterizedWithGStringOrGStringString(node.getUnresolvedSuperClass());
}

代码示例来源：origin: org.codehaus.groovy/groovy

/**
 * @param node the node to be tested
 * @return true if the node is using generics types and one of those types is a string
 */
public static boolean isParameterizedWithString(ClassNode node) {
  if (node.isArray()) return isParameterizedWithString(node.getComponentType());
  if (node.isUsingGenerics()) {
    GenericsType[] genericsTypes = node.getGenericsTypes();
    if (genericsTypes != null) {
      for (GenericsType genericsType : genericsTypes) {
        if (STRING_TYPE.equals(genericsType.getType())) return true;
      }
    }
  }
  return node.getSuperClass() != null && isParameterizedWithString(node.getUnresolvedSuperClass());
}

代码示例来源：origin: groovy/groovy-core

public void visitClass(ClassNode node) {
  visitType(node);
  visitType(node.getUnresolvedSuperClass());
  visitTypes(node.getInterfaces());
  super.visitClass(node);
}

代码示例来源：origin: org.codehaus.groovy/groovy

private static Parameter[] selectAccessibleConstructorFromSuper(ConstructorNode node) {
  ClassNode type = node.getDeclaringClass();
  ClassNode superType = type.getUnresolvedSuperClass();
  Parameter[] bestMatch = null;
  for (ConstructorNode c : superType.getDeclaredConstructors()) {
    // Only look at things we can actually call
    if (!c.isPublic() && !c.isProtected()) continue;
    Parameter[] parameters = c.getParameters();
    // workaround for GROOVY-5859: remove generic type info
    Parameter[] copy = new Parameter[parameters.length];
    for (int i = 0; i < copy.length; i++) {
      Parameter orig = parameters[i];
      copy[i] = new Parameter(orig.getOriginType().getPlainNodeReference(), orig.getName());
    }
    if (noExceptionToAvoid(node,c)) return copy;
    if (bestMatch==null) bestMatch = copy;
  }
  if (bestMatch!=null) return bestMatch;
  // fall back for parameterless constructor
  if (superType.isPrimaryClassNode()) {
    return Parameter.EMPTY_ARRAY;
  }
  return null;
}

代码示例来源：origin: org.codehaus.groovy/groovy

@Override
public void visitClass(ClassNode node) {
  this.classNode = node;
  thisField = null;
  InnerClassNode innerClass = null;
  if (!node.isEnum() && !node.isInterface() && node instanceof InnerClassNode) {
    innerClass = (InnerClassNode) node;
    if (!isStatic(innerClass) && innerClass.getVariableScope() == null) {
      thisField = innerClass.addField("this$0", PUBLIC_SYNTHETIC, node.getOuterClass().getPlainNodeReference(), null);
    }
  }
  super.visitClass(node);
  if (node.isEnum() || node.isInterface()) return;
  if (innerClass == null) return;
  if (node.getSuperClass().isInterface() || Traits.isAnnotatedWithTrait(node.getSuperClass())) {
    node.addInterface(node.getUnresolvedSuperClass());
    node.setUnresolvedSuperClass(ClassHelper.OBJECT_TYPE);
  }
}

代码示例来源：origin: org.codehaus.groovy/groovy

checkCyclicInheritance(originalNode, parentToCompare.getUnresolvedSuperClass(), null);
} else {
  if(interfacesToCompare != null && interfacesToCompare.length > 0) {

代码示例来源：origin: org.codehaus.groovy/groovy

public void visitClass(ClassNode node) {
  ClassNode oldClass = currentClass;
  currentClass = node;
  checkImplementsAndExtends(node);
  if (source != null && !source.getErrorCollector().hasErrors()) {
    checkClassForIncorrectModifiers(node);
    checkInterfaceMethodVisibility(node);
    checkAbstractMethodVisibility(node);
    checkClassForOverwritingFinal(node);
    checkMethodsForIncorrectModifiers(node);
    checkMethodsForIncorrectName(node);
    checkMethodsForWeakerAccess(node);
    checkMethodsForOverridingFinal(node);
    checkNoAbstractMethodsNonabstractClass(node);
    checkClassExtendsAllSelfTypes(node);
    checkNoStaticMethodWithSameSignatureAsNonStatic(node);
    checkGenericsUsage(node, node.getUnresolvedInterfaces());
    checkGenericsUsage(node, node.getUnresolvedSuperClass());
  }
  super.visitClass(node);
  currentClass = oldClass;
}

内容来源于网络，如有侵权，请联系作者删除！

ClassNode

相关文章

    查看更多
    微信公众号

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多

    ClassNode类方法

    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com