diff --git a/build/lib/jps/jps-builders.jar b/build/lib/jps/jps-builders.jar index cc8350f58204..a41086f10dd2 100644 Binary files a/build/lib/jps/jps-builders.jar and b/build/lib/jps/jps-builders.jar differ diff --git a/java/compiler/instrumentation-util/src/com/intellij/compiler/notNullVerification/NotNullVerifyingInstrumenter.java b/java/compiler/instrumentation-util/src/com/intellij/compiler/notNullVerification/NotNullVerifyingInstrumenter.java index ac68cf62e74c..615656796130 100644 --- a/java/compiler/instrumentation-util/src/com/intellij/compiler/notNullVerification/NotNullVerifyingInstrumenter.java +++ b/java/compiler/instrumentation-util/src/com/intellij/compiler/notNullVerification/NotNullVerifyingInstrumenter.java @@ -25,12 +25,6 @@ public class NotNullVerifyingInstrumenter extends ClassVisitor implements Opcode @SuppressWarnings("SSBasedInspection") private static final String[] EMPTY_STRING_ARRAY = new String[0]; - private static final boolean NEW_ASM; - static { - try { NEW_ASM = (Integer)Opcodes.class.getField("API_VERSION").get(null) > Opcodes.ASM6; } - catch (Exception e) { throw new RuntimeException(e); } - } - private final Map> myMethodParamNames; private String myClassName; private boolean myIsModification = false; @@ -159,10 +153,7 @@ public class NotNullVerifyingInstrumenter extends ClassVisitor implements Opcode boolean hasOuterClassParameter = myEnclosed && myInner && "".equals(name); // see http://forge.ow2.org/tracker/?aid=307392&group_id=23&atid=100023&func=detail final int syntheticCount = signature == null ? 0 : hasOuterClassParameter ? 1 : Math.max(0, args.length - getSignatureParameterCount(signature)); - // workaround for ASM workaround for javac bug: http://forge.ow2.org/tracker/?func=detail&aid=317788&group_id=23&atid=100023 - final int paramAnnotationOffset = !"".equals(name) ? 0 : NEW_ASM - ? (myEnum ? -2 : myInner ? -1 : 0) - : signature != null && hasOuterClassParameter ? Math.max(0, args.length - getSignatureParameterCount(signature) - 1) : 0; + final int paramAnnotationOffset = !"".equals(name) ? 0 : myEnum ? 2 : myInner ? 1 : 0; final Type returnType = Type.getReturnType(desc); final MethodVisitor v = cv.visitMethod(access, name, desc, signature, exceptions); @@ -214,8 +205,7 @@ public class NotNullVerifyingInstrumenter extends ClassVisitor implements Opcode @Override public AnnotationVisitor visitParameterAnnotation(int parameter, String anno, boolean visible) { AnnotationVisitor base = mv.visitParameterAnnotation(parameter, anno, visible); - if (!NEW_ASM && parameter < myParamAnnotationOffset) return base; - return checkNotNullParameter(parameter - myParamAnnotationOffset, anno, base); + return checkNotNullParameter(parameter + myParamAnnotationOffset, anno, base); } private AnnotationVisitor checkNotNullParameter(int parameter, String anno, AnnotationVisitor av) { diff --git a/plugins/IntelliLang/intellilang-jps-plugin/src/org/jetbrains/jps/intellilang/instrumentation/InstrumentationAdapter.java b/plugins/IntelliLang/intellilang-jps-plugin/src/org/jetbrains/jps/intellilang/instrumentation/InstrumentationAdapter.java index 1f44a1e967f4..fa5f7a0c81d3 100644 --- a/plugins/IntelliLang/intellilang-jps-plugin/src/org/jetbrains/jps/intellilang/instrumentation/InstrumentationAdapter.java +++ b/plugins/IntelliLang/intellilang-jps-plugin/src/org/jetbrains/jps/intellilang/instrumentation/InstrumentationAdapter.java @@ -8,7 +8,6 @@ import java.text.MessageFormat; import java.util.ArrayList; import java.util.List; -import static org.jetbrains.jps.intellilang.instrumentation.PatternInstrumenter.NEW_ASM; import static org.jetbrains.jps.intellilang.instrumentation.PatternInstrumenter.isStringType; class InstrumentationAdapter extends FailSafeMethodVisitor implements Opcodes { @@ -59,12 +58,12 @@ class InstrumentationAdapter extends FailSafeMethodVisitor implements Opcodes { public AnnotationVisitor visitParameterAnnotation(int parameter, String desc, boolean visible) { AnnotationVisitor av = mv.visitParameterAnnotation(parameter, desc, visible); - if (NEW_ASM ? isStringType(myArgTypes[parameter - myParamAnnotationOffset]) : parameter >= myParamAnnotationOffset && isStringType(myArgTypes[parameter])) { + if (isStringType(myArgTypes[parameter + myParamAnnotationOffset])) { String annotationClassName = Type.getType(desc).getClassName(); String pattern = myInstrumenter.getAnnotationPattern(annotationClassName); if (pattern != null) { String shortName = annotationClassName.substring(annotationClassName.lastIndexOf('.') + 1); - PatternValue patternValue = new PatternValue(parameter - myParamAnnotationOffset, shortName, pattern); + PatternValue patternValue = new PatternValue(parameter + myParamAnnotationOffset, shortName, pattern); myParameterPatterns.add(patternValue); if (pattern == PatternInstrumenter.NULL_PATTERN) { return new MyAnnotationVisitor(av, patternValue); diff --git a/plugins/IntelliLang/intellilang-jps-plugin/src/org/jetbrains/jps/intellilang/instrumentation/PatternInstrumenter.java b/plugins/IntelliLang/intellilang-jps-plugin/src/org/jetbrains/jps/intellilang/instrumentation/PatternInstrumenter.java index 547df6c7492c..2b9108e844e2 100644 --- a/plugins/IntelliLang/intellilang-jps-plugin/src/org/jetbrains/jps/intellilang/instrumentation/PatternInstrumenter.java +++ b/plugins/IntelliLang/intellilang-jps-plugin/src/org/jetbrains/jps/intellilang/instrumentation/PatternInstrumenter.java @@ -6,8 +6,6 @@ import com.intellij.openapi.diagnostic.Logger; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.org.objectweb.asm.*; -import org.jetbrains.org.objectweb.asm.signature.SignatureReader; -import org.jetbrains.org.objectweb.asm.signature.SignatureVisitor; import java.io.ByteArrayOutputStream; import java.io.IOException; @@ -26,12 +24,6 @@ class PatternInstrumenter extends ClassVisitor implements Opcodes { static final String JAVA_UTIL_REGEX_PATTERN = "[Ljava/util/regex/Pattern;"; static final String NULL_PATTERN = "(((("; - static final boolean NEW_ASM; - static { - try { NEW_ASM = (Integer)Opcodes.class.getField("API_VERSION").get(null) > Opcodes.ASM6; } - catch (Exception e) { throw new RuntimeException(e); } - } - private final String myPatternAnnotationClassName; private final boolean myDoAssert; private final InstrumentationClassFinder myClassFinder; @@ -41,7 +33,6 @@ class PatternInstrumenter extends ClassVisitor implements Opcodes { private String myClassName; private boolean myEnum; private boolean myInner; - private boolean myEnclosed; private boolean myHasAssertions; private boolean myHasStaticInitializer; private boolean myInstrumented; @@ -84,12 +75,6 @@ class PatternInstrumenter extends ClassVisitor implements Opcodes { } } - @Override - public void visitOuterClass(String owner, String name, String desc) { - super.visitOuterClass(owner, name, desc); - myEnclosed = true; - } - @Override public FieldVisitor visitField(int access, String name, String desc, String signature, Object value) { if (name.equals(ASSERTIONS_DISABLED_NAME)) { @@ -183,9 +168,7 @@ class PatternInstrumenter extends ClassVisitor implements Opcodes { Type[] argTypes = Type.getArgumentTypes(desc); Type returnType = Type.getReturnType(desc); if (isCandidate(argTypes, returnType)) { - int offset = !"".equals(name) ? 0 : NEW_ASM - ? (myEnum ? -2 : myInner ? -1 : 0) - : (myEnclosed && myInner && signature != null ? Math.max(0, argTypes.length - countSignatureParameters(signature) - 1) : 0); + int offset = !"".equals(name) ? 0 : myEnum ? 2 : myInner ? 1 : 0; return new InstrumentationAdapter(this, methodvisitor, argTypes, returnType, myClassName, name, myDoAssert, isStatic, offset); } } @@ -209,20 +192,6 @@ class PatternInstrumenter extends ClassVisitor implements Opcodes { return type.getSort() == Type.OBJECT && type.getDescriptor().equals(JAVA_LANG_STRING); } - private static int countSignatureParameters(String signature) { - int[] count = {0}; - if (signature != null) { - new SignatureReader(signature).accept(new SignatureVisitor(Opcodes.API_VERSION) { - @Override - public SignatureVisitor visitParameterType() { - count[0]++; - return super.visitParameterType(); - } - }); - } - return count[0]; - } - int addPattern(String s) { return myPatterns.add(s) ? myPatterns.size() - 1 : Arrays.asList(myPatterns.toArray()).indexOf(s); }