jdk.nashorn.internal.objects.annotations.SpecializedFunction.LinkLogic Java Examples

@Override
public String toString() {
    final StringBuilder sb = new StringBuilder();
    final Class<? extends LinkLogic> linkLogicClass = getLinkLogicClass();

    sb.append("[invokerType=").
        append(invoker.type()).
        append(" ctor=").
        append(constructor).
        append(" weight=").
        append(weight()).
        append(" linkLogic=").
        append(linkLogicClass != null ? linkLogicClass.getSimpleName() : "none");

    return sb.toString();
}
 

/**
 * Some receivers are primitive, in that case, according to the Spec we
 * create a new native object per callsite with the wrap filter. We can only
 * apply optimistic builtins if there is no per instance state saved for
 * these wrapped objects (e.g. currently NativeStrings), otherwise we can't
 * create optimistic versions
 *
 * @param self receiver
 * @param linkLogicClass linkLogicClass, or null if no link logic exists
 * @return link logic instance, or null if one could not be constructed for
 * this receiver
 */
private static LinkLogic getLinkLogic(final Object self, final Class<? extends LinkLogic> linkLogicClass) {
    if (linkLogicClass == null) {
        return LinkLogic.EMPTY_INSTANCE; //always OK to link this, specialization but without special linking logic
    }

    if (!Context.getContextTrusted().getEnv()._optimistic_types) {
        return null; //if optimistic types are off, optimistic builtins are too
    }

    final Object wrappedSelf = wrapFilter(self);
    if (wrappedSelf instanceof OptimisticBuiltins) {
        if (wrappedSelf != self && ((OptimisticBuiltins) wrappedSelf).hasPerInstanceAssumptions()) {
            return null; //pessimistic - we created a wrapped object different from the primitive, but the assumptions have instance state
        }
        return ((OptimisticBuiltins) wrappedSelf).getLinkLogic(linkLogicClass);
    }
    return null;
}
 

@Override
public String toString() {
    final StringBuilder sb = new StringBuilder();
    final Class<? extends LinkLogic> linkLogicClass = getLinkLogicClass();

    sb.append("[invokerType=").
        append(invoker.type()).
        append(" ctor=").
        append(constructor).
        append(" weight=").
        append(weight()).
        append(" linkLogic=").
        append(linkLogicClass != null ? linkLogicClass.getSimpleName() : "none");

    return sb.toString();
}
 

@Override
public String toString() {
    final StringBuilder sb = new StringBuilder();
    final Class<? extends LinkLogic> linkLogicClass = getLinkLogicClass();

    sb.append("[invokerType=").
        append(invoker.type()).
        append(" ctor=").
        append(constructor).
        append(" weight=").
        append(weight()).
        append(" linkLogic=").
        append(linkLogicClass != null ? linkLogicClass.getSimpleName() : "none");

    return sb.toString();
}
 

/**
 * Some receivers are primitive, in that case, according to the Spec we
 * create a new native object per callsite with the wrap filter. We can only
 * apply optimistic builtins if there is no per instance state saved for
 * these wrapped objects (e.g. currently NativeStrings), otherwise we can't
 * create optimistic versions
 *
 * @param self receiver
 * @param linkLogicClass linkLogicClass, or null if no link logic exists
 * @return link logic instance, or null if one could not be constructed for
 * this receiver
 */
private static LinkLogic getLinkLogic(final Object self, final Class<? extends LinkLogic> linkLogicClass) {
    if (linkLogicClass == null) {
        return LinkLogic.EMPTY_INSTANCE; //always OK to link this, specialization but without special linking logic
    }

    if (!Context.getContextTrusted().getEnv()._optimistic_types) {
        return null; //if optimistic types are off, optimistic builtins are too
    }

    final Object wrappedSelf = wrapFilter(self);
    if (wrappedSelf instanceof OptimisticBuiltins) {
        if (wrappedSelf != self && ((OptimisticBuiltins) wrappedSelf).hasPerInstanceAssumptions()) {
            return null; //pessimistic - we created a wrapped object different from the primitive, but the assumptions have instance state
        }
        return ((OptimisticBuiltins) wrappedSelf).getLinkLogic(linkLogicClass);
    }
    return null;
}
 

/**
 * Some receivers are primitive, in that case, according to the Spec we
 * create a new native object per callsite with the wrap filter. We can only
 * apply optimistic builtins if there is no per instance state saved for
 * these wrapped objects (e.g. currently NativeStrings), otherwise we can't
 * create optimistic versions
 *
 * @param self receiver
 * @param linkLogicClass linkLogicClass, or null if no link logic exists
 * @return link logic instance, or null if one could not be constructed for
 * this receiver
 */
private static LinkLogic getLinkLogic(final Object self, final Class<? extends LinkLogic> linkLogicClass) {
    if (linkLogicClass == null) {
        return LinkLogic.EMPTY_INSTANCE; //always OK to link this, specialization but without special linking logic
    }

    if (!Context.getContextTrusted().getEnv()._optimistic_types) {
        return null; //if optimistic types are off, optimistic builtins are too
    }

    final Object wrappedSelf = wrapFilter(self);
    if (wrappedSelf instanceof OptimisticBuiltins) {
        if (wrappedSelf != self && ((OptimisticBuiltins) wrappedSelf).hasPerInstanceAssumptions()) {
            return null; //pessimistic - we created a wrapped object different from the primitive, but the assumptions have instance state
        }
        return ((OptimisticBuiltins) wrappedSelf).getLinkLogic(linkLogicClass);
    }
    return null;
}
 

@Override
public String toString() {
    final StringBuilder sb = new StringBuilder();
    final Class<? extends LinkLogic> linkLogicClass = getLinkLogicClass();

    sb.append("[invokerType=").
        append(invoker.type()).
        append(" ctor=").
        append(constructor).
        append(" weight=").
        append(weight()).
        append(" linkLogic=").
        append(linkLogicClass != null ? linkLogicClass.getSimpleName() : "none");

    return sb.toString();
}
 

/**
 * Some receivers are primitive, in that case, according to the Spec we create a new
 * native object per callsite with the wrap filter. We can only apply optimistic builtins
 * if there is no per instance state saved for these wrapped objects (e.g. currently NativeStrings),
 * otherwise we can't create optimistic versions
 *
 * @param self            receiver
 * @param linkLogicClass  linkLogicClass, or null if no link logic exists
 * @return link logic instance, or null if one could not be constructed for this receiver
 */
private static LinkLogic getLinkLogic(final Object self, final Class<? extends LinkLogic> linkLogicClass) {
    if (linkLogicClass == null) {
        return LinkLogic.EMPTY_INSTANCE; //always OK to link this, specialization but without special linking logic
    }

    if (!Context.getContextTrusted().getEnv()._optimistic_types) {
        return null; //if optimistic types are off, optimistic builtins are too
    }

    final Object wrappedSelf = wrapFilter(self);
    if (wrappedSelf instanceof OptimisticBuiltins) {
        if (wrappedSelf != self && ((OptimisticBuiltins)wrappedSelf).hasPerInstanceAssumptions()) {
            return null; //pessimistic - we created a wrapped object different from the primitive, but the assumptions have instance state
        }
        return ((OptimisticBuiltins)wrappedSelf).getLinkLogic(linkLogicClass);
    }
    return null;
}
 

/**
 * Some receivers are primitive, in that case, according to the Spec we
 * create a new native object per callsite with the wrap filter. We can only
 * apply optimistic builtins if there is no per instance state saved for
 * these wrapped objects (e.g. currently NativeStrings), otherwise we can't
 * create optimistic versions
 *
 * @param self receiver
 * @param linkLogicClass linkLogicClass, or null if no link logic exists
 * @return link logic instance, or null if one could not be constructed for
 * this receiver
 */
private static LinkLogic getLinkLogic(final Object self, final Class<? extends LinkLogic> linkLogicClass) {
    if (linkLogicClass == null) {
        return LinkLogic.EMPTY_INSTANCE; //always OK to link this, specialization but without special linking logic
    }

    if (!Context.getContextTrusted().getEnv()._optimistic_types) {
        return null; //if optimistic types are off, optimistic builtins are too
    }

    final Object wrappedSelf = wrapFilter(self);
    if (wrappedSelf instanceof OptimisticBuiltins) {
        if (wrappedSelf != self && ((OptimisticBuiltins) wrappedSelf).hasPerInstanceAssumptions()) {
            return null; //pessimistic - we created a wrapped object different from the primitive, but the assumptions have instance state
        }
        return ((OptimisticBuiltins) wrappedSelf).getLinkLogic(linkLogicClass);
    }
    return null;
}
 

@Override
public String toString() {
    final StringBuilder sb = new StringBuilder();
    final Class<? extends LinkLogic> linkLogicClass = getLinkLogicClass();

    sb.append("[invokerType=").
        append(invoker.type()).
        append(" ctor=").
        append(constructor).
        append(" weight=").
        append(weight()).
        append(" linkLogic=").
        append(linkLogicClass != null ? linkLogicClass.getSimpleName() : "none");

    return sb.toString();
}
 

/**
 * Some receivers are primitive, in that case, according to the Spec we
 * create a new native object per callsite with the wrap filter. We can only
 * apply optimistic builtins if there is no per instance state saved for
 * these wrapped objects (e.g. currently NativeStrings), otherwise we can't
 * create optimistic versions
 *
 * @param self receiver
 * @param linkLogicClass linkLogicClass, or null if no link logic exists
 * @return link logic instance, or null if one could not be constructed for
 * this receiver
 */
private static LinkLogic getLinkLogic(final Object self, final Class<? extends LinkLogic> linkLogicClass) {
    if (linkLogicClass == null) {
        return LinkLogic.EMPTY_INSTANCE; //always OK to link this, specialization but without special linking logic
    }

    if (!Context.getContextTrusted().getEnv()._optimistic_types) {
        return null; //if optimistic types are off, optimistic builtins are too
    }

    final Object wrappedSelf = wrapFilter(self);
    if (wrappedSelf instanceof OptimisticBuiltins) {
        if (wrappedSelf != self && ((OptimisticBuiltins) wrappedSelf).hasPerInstanceAssumptions()) {
            return null; //pessimistic - we created a wrapped object different from the primitive, but the assumptions have instance state
        }
        return ((OptimisticBuiltins) wrappedSelf).getLinkLogic(linkLogicClass);
    }
    return null;
}
 

@Override
public String toString() {
    final StringBuilder sb = new StringBuilder();
    final Class<? extends LinkLogic> linkLogicClass = getLinkLogicClass();

    sb.append("[invokerType=").
        append(invoker.type()).
        append(" ctor=").
        append(constructor).
        append(" weight=").
        append(weight()).
        append(" linkLogic=").
        append(linkLogicClass != null ? linkLogicClass.getSimpleName() : "none");

    return sb.toString();
}
 

@Override
public String toString() {
    final StringBuilder sb = new StringBuilder();
    final Class<? extends LinkLogic> linkLogicClass = getLinkLogicClass();

    sb.append("[invokerType=").
        append(invoker.type()).
        append(" ctor=").
        append(constructor).
        append(" weight=").
        append(weight()).
        append(" linkLogic=").
        append(linkLogicClass != null ? linkLogicClass.getSimpleName() : "none");

    return sb.toString();
}
 

/**
 * Some receivers are primitive, in that case, according to the Spec we
 * create a new native object per callsite with the wrap filter. We can only
 * apply optimistic builtins if there is no per instance state saved for
 * these wrapped objects (e.g. currently NativeStrings), otherwise we can't
 * create optimistic versions
 *
 * @param self receiver
 * @param linkLogicClass linkLogicClass, or null if no link logic exists
 * @return link logic instance, or null if one could not be constructed for
 * this receiver
 */
private static LinkLogic getLinkLogic(final Object self, final Class<? extends LinkLogic> linkLogicClass) {
    if (linkLogicClass == null) {
        return LinkLogic.EMPTY_INSTANCE; //always OK to link this, specialization but without special linking logic
    }

    if (!Context.getContextTrusted().getEnv()._optimistic_types) {
        return null; //if optimistic types are off, optimistic builtins are too
    }

    final Object wrappedSelf = wrapFilter(self);
    if (wrappedSelf instanceof OptimisticBuiltins) {
        if (wrappedSelf != self && ((OptimisticBuiltins) wrappedSelf).hasPerInstanceAssumptions()) {
            return null; //pessimistic - we created a wrapped object different from the primitive, but the assumptions have instance state
        }
        return ((OptimisticBuiltins) wrappedSelf).getLinkLogic(linkLogicClass);
    }
    return null;
}
 

Class<? extends LinkLogic> getLinkLogicClass() {
    if (isSpecialization()) {
        final Class<? extends LinkLogic> linkLogicClass = specialization.getLinkLogicClass();
        assert !LinkLogic.isEmpty(linkLogicClass) : "empty link logic classes should have been removed by nasgen";
        return linkLogicClass;
    }
    return null;
}
 

Class<? extends LinkLogic> getLinkLogicClass() {
    if (isSpecialization()) {
        final Class<? extends LinkLogic> linkLogicClass = specialization.getLinkLogicClass();
        assert !LinkLogic.isEmpty(linkLogicClass) : "empty link logic classes should have been removed by nasgen";
        return linkLogicClass;
    }
    return null;
}
 

Class<? extends LinkLogic> getLinkLogicClass() {
    if (isSpecialization()) {
        final Class<? extends LinkLogic> linkLogicClass = specialization.getLinkLogicClass();
        assert !LinkLogic.isEmpty(linkLogicClass) : "empty link logic classes should have been removed by nasgen";
        return linkLogicClass;
    }
    return null;
}
 

@Override
public LinkLogic getLinkLogic(final Class<? extends LinkLogic> clazz) {
    if (clazz == CharCodeAtLinkLogic.class) {
        return CharCodeAtLinkLogic.INSTANCE;
    }
    return null;
}
 

@Override
public SpecializedFunction.LinkLogic getLinkLogic(final Class<? extends LinkLogic> clazz) {
    if (clazz == PushLinkLogic.class) {
        return PushLinkLogic.INSTANCE;
    } else if (clazz == PopLinkLogic.class) {
        return PopLinkLogic.INSTANCE;
    } else if (clazz == ConcatLinkLogic.class) {
        return ConcatLinkLogic.INSTANCE;
    }
    return null;
}
 

/**
 * Constructor
 *
 * @param mh  invoker method handler
 * @param linkLogicClass extra link logic needed for this function. Instances of this class also contains logic for checking
 *  if this can be linked on its first encounter, which is needed as per our standard linker semantics
 * @param isOptimistic is this an optimistic native method, i.e. can it throw {@link UnwarrantedOptimismException}
 *   which would have to lead to a relink and return value processing
 * @param convertsNumericArgs true if it is safe to convert arguments to numbers
 */
public Specialization(final MethodHandle mh, final Class<? extends LinkLogic> linkLogicClass,
                      final boolean isOptimistic, final boolean convertsNumericArgs) {
    this.mh             = mh;
    this.isOptimistic   = isOptimistic;
    this.convertsNumericArgs = convertsNumericArgs;
    if (linkLogicClass != null) {
        //null out the "empty" link logic class for optimization purposes
        //we only use the empty instance because we can't default class annotations
        //to null
        this.linkLogicClass = LinkLogic.isEmpty(linkLogicClass) ? null : linkLogicClass;
    } else {
        this.linkLogicClass = null;
    }
 }
 

/**
 * Constructor
 *
 * @param mh  invoker method handler
 * @param linkLogicClass extra link logic needed for this function. Instances of this class also contains logic for checking
 *  if this can be linked on its first encounter, which is needed as per our standard linker semantics
 * @param isOptimistic is this an optimistic native method, i.e. can it throw {@link UnwarrantedOptimismException}
 *   which would have to lead to a relink and return value processing
 */
public Specialization(final MethodHandle mh, final Class<? extends LinkLogic> linkLogicClass, final boolean isOptimistic) {
    this.mh             = mh;
    this.isOptimistic   = isOptimistic;
    if (linkLogicClass != null) {
        //null out the "empty" link logic class for optimization purposes
        //we only use the empty instance because we can't default class annotations
        //to null
        this.linkLogicClass = LinkLogic.isEmpty(linkLogicClass) ? null : linkLogicClass;
    } else {
        this.linkLogicClass = null;
    }
 }
 

@Override
public LinkLogic getLinkLogic(final Class<? extends LinkLogic> clazz) {
    if (clazz == CharCodeAtLinkLogic.class) {
        return CharCodeAtLinkLogic.INSTANCE;
    }
    return null;
}
 

@Override
public SpecializedFunction.LinkLogic getLinkLogic(final Class<? extends LinkLogic> clazz) {
    if (clazz == PushLinkLogic.class) {
        return PushLinkLogic.INSTANCE;
    } else if (clazz == PopLinkLogic.class) {
        return PopLinkLogic.INSTANCE;
    } else if (clazz == ConcatLinkLogic.class) {
        return ConcatLinkLogic.INSTANCE;
    }
    return null;
}
 

@Override
public SpecializedFunction.LinkLogic getLinkLogic(final Class<? extends LinkLogic> clazz) {
    if (clazz == PushLinkLogic.class) {
        return PushLinkLogic.INSTANCE;
    } else if (clazz == PopLinkLogic.class) {
        return PopLinkLogic.INSTANCE;
    } else if (clazz == ConcatLinkLogic.class) {
        return ConcatLinkLogic.INSTANCE;
    }
    return null;
}
 

/**
 * Constructor
 *
 * @param mh  invoker method handler
 * @param linkLogicClass extra link logic needed for this function. Instances of this class also contains logic for checking
 *  if this can be linked on its first encounter, which is needed as per our standard linker semantics
 * @param isOptimistic is this an optimistic native method, i.e. can it throw {@link UnwarrantedOptimismException}
 *   which would have to lead to a relink and return value processing
 */
public Specialization(final MethodHandle mh, final Class<? extends LinkLogic> linkLogicClass, final boolean isOptimistic) {
    this.mh             = mh;
    this.isOptimistic   = isOptimistic;
    if (linkLogicClass != null) {
        //null out the "empty" link logic class for optimization purposes
        //we only use the empty instance because we can't default class annotations
        //to null
        this.linkLogicClass = LinkLogic.isEmpty(linkLogicClass) ? null : linkLogicClass;
    } else {
        this.linkLogicClass = null;
    }
 }
 

@Override
public SpecializedFunction.LinkLogic getLinkLogic(final Class<? extends LinkLogic> clazz) {
    if (clazz == PushLinkLogic.class) {
        return PushLinkLogic.INSTANCE;
    } else if (clazz == PopLinkLogic.class) {
        return PopLinkLogic.INSTANCE;
    } else if (clazz == ConcatLinkLogic.class) {
        return ConcatLinkLogic.INSTANCE;
    }
    return null;
}
 

@Override
public LinkLogic getLinkLogic(final Class<? extends LinkLogic> clazz) {
    if (clazz == CharCodeAtLinkLogic.class) {
        return CharCodeAtLinkLogic.INSTANCE;
    }
    return null;
}
 

Class<? extends LinkLogic> getLinkLogicClass() {
    if (isSpecialization()) {
        final Class<? extends LinkLogic> linkLogicClass = specialization.getLinkLogicClass();
        assert !LinkLogic.isEmpty(linkLogicClass) : "empty link logic classes should have been removed by nasgen";
        return linkLogicClass;
    }
    return null;
}
 

/**
 * Constructor
 *
 * @param mh  invoker method handler
 * @param linkLogicClass extra link logic needed for this function. Instances of this class also contains logic for checking
 *  if this can be linked on its first encounter, which is needed as per our standard linker semantics
 * @param isOptimistic is this an optimistic native method, i.e. can it throw {@link UnwarrantedOptimismException}
 *   which would have to lead to a relink and return value processing
 */
public Specialization(final MethodHandle mh, final Class<? extends LinkLogic> linkLogicClass, final boolean isOptimistic) {
    this.mh             = mh;
    this.isOptimistic   = isOptimistic;
    if (linkLogicClass != null) {
        //null out the "empty" link logic class for optimization purposes
        //we only use the empty instance because we can't default class annotations
        //to null
        this.linkLogicClass = LinkLogic.isEmpty(linkLogicClass) ? null : linkLogicClass;
    } else {
        this.linkLogicClass = null;
    }
 }
 

@Override
public LinkLogic getLinkLogic(final Class<? extends LinkLogic> clazz) {
    if (clazz == CharCodeAtLinkLogic.class) {
        return CharCodeAtLinkLogic.INSTANCE;
    }
    return null;
}