docs: @SuppressWarnings("unchecked")
      private static void addPrivateBridgeMethods(final ClassNode node) {
          Set<ASTNode> accessedMethods = (Set<ASTNode>) node.getNodeMetaData(StaticTypesMarker.PV_METHODS_ACCESS);
          if (accessedMethods==null) return;
          List<MethodNode> methods = new ArrayList<MethodNode>(node.getAllDeclaredMethods());
          methods.addAll(node.getDeclaredConstructors());
          Map<MethodNode, MethodNode> privateBridgeMethods = (Map<MethodNode, MethodNode>) node.getNodeMetaData(PRIVATE_BRIDGE_METHODS);
          if (privateBridgeMethods!=null) {
              // private bridge methods already added
              return;
          }
          privateBridgeMethods = new HashMap<MethodNode, MethodNode>();
          int i=-1;
          final int access = Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC | Opcodes.ACC_SYNTHETIC;
          for (MethodNode method : methods) {
              if (accessedMethods.contains(method)) {
                  List<String> methodSpecificGenerics = methodSpecificGenerics(method);
                  i++;
                  ClassNode declaringClass = method.getDeclaringClass();
                  Map<String,ClassNode> genericsSpec = createGenericsSpec(node);
                  genericsSpec = addMethodGenerics(method, genericsSpec);
                  extractSuperClassGenerics(node, declaringClass, genericsSpec);
                  Parameter[] methodParameters = method.getParameters();
                  Parameter[] newParams = new Parameter[methodParameters.length+1];
                  for (int j = 1; j < newParams.length; j++) {
                      Parameter orig = methodParameters[j-1];
                      newParams[j] = new Parameter(
                              correctToGenericsSpecRecurse(genericsSpec, orig.getOriginType(), methodSpecificGenerics),
                              orig.getName()
                      );
                  }
                  Expression arguments;
                  if (method.getParameters()==null || method.getParameters().length==0) {
                      arguments = ArgumentListExpression.EMPTY_ARGUMENTS;
                  } else {
                      List<Expression> args = new LinkedList<Expression>();
                      for (Parameter parameter : methodParameters) {
                          args.add(new VariableExpression(parameter));
                      }
                      arguments = new ArgumentListExpression(args);
                  }
  
                  MethodNode bridge;
                  if (method instanceof ConstructorNode) {
                      // create constructor with a nested class as the first parameter, creating one if necessary
                      ClassNode thatType = null;
                      Iterator<InnerClassNode> innerClasses = node.getInnerClasses();
                      if (innerClasses.hasNext()) {
                          thatType = innerClasses.next();
                      } else {
                          thatType = new InnerClassNode(node.redirect(), node.getName() + "$1", ACC_STATIC | ACC_SYNTHETIC, ClassHelper.OBJECT_TYPE);
                          node.getModule().addClass(thatType);
                      }
                      newParams[0] = new Parameter(thatType.getPlainNodeReference(), "$that");
                      Expression cce = new ConstructorCallExpression(ClassNode.THIS, arguments);
                      Statement body = new ExpressionStatement(cce);
                      bridge = node.addConstructor(ACC_SYNTHETIC, newParams, ClassNode.EMPTY_ARRAY, body);
                  } else {
                      newParams[0] = new Parameter(node.getPlainNodeReference(), "$that");
                      Expression receiver = method.isStatic()?new ClassExpression(node):new VariableExpression(newParams[0]);
                      MethodCallExpression mce = new MethodCallExpression(receiver, method.getName(), arguments);
                      mce.setMethodTarget(method);
  
                      ExpressionStatement returnStatement = new ExpressionStatement(mce);
                      bridge = node.addMethod(
                              "access$"+i, access,
                              correctToGenericsSpecRecurse(genericsSpec, method.getReturnType(), methodSpecificGenerics),
                              newParams,
                              method.getExceptions(),
                              returnStatement);
                  }
                  GenericsType[] origGenericsTypes = method.getGenericsTypes();
                  if (origGenericsTypes !=null) {
                      bridge.setGenericsTypes(applyGenericsContextToPlaceHolders(genericsSpec,origGenericsTypes));
                  }
                  privateBridgeMethods.put(method, bridge);
                  bridge.addAnnotation(new AnnotationNode(COMPILESTATIC_CLASSNODE));
              }
          }
          if (!privateBridgeMethods.isEmpty()) {
              node.setNodeMetaData(PRIVATE_BRIDGE_METHODS, privateBridgeMethods);
          }
      }