if (!compareTypes(parmType, argType)) { match = false; matches[ii] = false; }
matches[ii] = compareTypes(parmType, argType); if (matches[ii] != IncompatibleTypes.SEEMS_OK) match = false;
	private void analyzeMethod(ClassContext classContext, Method method)	throws CFGBuilderException, DataflowAnalysisException {		if (isSynthetic(method) || !prescreen(classContext, method))			return;				BugAccumulator accumulator = new BugAccumulator(bugReporter);				CFG cfg = classContext.getCFG(method);		TypeDataflow typeDataflow = classContext.getTypeDataflow(method);		ConstantPoolGen cpg = classContext.getConstantPoolGen();		MethodGen methodGen = classContext.getMethodGen(method);		if (methodGen == null) return;		String fullMethodName = 			methodGen.getClassName() + "." + methodGen.getName(); 		String sourceFile = classContext.getJavaClass().getSourceFileName();		if (DEBUG) {			System.out.println("Checking " + fullMethodName);		}		// Process each instruction		for (Iterator<Location> iter = cfg.locationIterator(); iter.hasNext();) {			Location location = iter.next();			InstructionHandle handle = location.getHandle();			Instruction ins = handle.getInstruction();			// Only consider invoke instructions			if (!(ins instanceof InvokeInstruction))				continue;			InvokeInstruction inv = (InvokeInstruction)ins;						// check the relevance of this instruction			String [] itriplet = getInstructionTriplet(inv, cpg);			String [] triplet = getRelevantTriplet(itriplet);			if (triplet == null)				continue;						// get the list of parameter indexes for each argument position			int [] argumentParameterIndex = 				collectionsMap.get( getCollectionsMapKey(triplet) );						TypeFrame frame = typeDataflow.getFactAtLocation(location);			if (!frame.isValid()) {				// This basic block is probably dead				continue;			}			Type operandType = frame.getTopValue();			if (operandType.equals(TopType.instance())) {				// unreachable				continue;			}									// Only consider generic... 			Type objectType = frame.getInstance(inv, cpg);						if (!(objectType instanceof GenericObjectType))				continue;						GenericObjectType operand = (GenericObjectType) objectType;						// ... containers			if (!operand.hasParameters()) continue;						int numArguments = frame.getNumArguments(inv, cpg);						if (numArguments <= 0 || argumentParameterIndex.length != numArguments)				continue; 						// compare containers type parameters to corresponding arguments			boolean match = true;			boolean [] matches = new boolean [numArguments];			for (int i=0; i<numArguments; i++) matches[i] = true;						Type parmType = null, argType = null;						for (int ii=0; ii < numArguments; ii++) {				if (argumentParameterIndex[ii] < 0) continue; // not relevant argument				if (argumentParameterIndex[ii] >= operand.getNumParameters()) 					continue; // should never happen								parmType = operand.getParameterAt(argumentParameterIndex[ii]);				argType = frame.getArgument(inv, cpg, ii, numArguments);								if (!compareTypes(parmType, argType)) {					match = false;					matches[ii] = false;				}			}						if (match)				continue; // no bug			// Prepare bug report			SourceLineAnnotation sourceLineAnnotation = SourceLineAnnotation			.fromVisitedInstruction(classContext, methodGen, sourceFile, handle);			// Report a bug that mentions each of the failed arguments in matches			for (int i=0; i<numArguments; i++) {				if (matches[i]) continue;				parmType = operand.getParameterAt(argumentParameterIndex[i]);				argType = frame.getArgument(inv, cpg, i, numArguments);								accumulator.accumulateBug(new BugInstance(this,						"GC_UNRELATED_TYPES", NORMAL_PRIORITY)						.addClassAndMethod(methodGen, sourceFile)											.addString(GenericUtilities.getString(parmType))						.addString(GenericUtilities.getString(argType))						.addType(parmType.getSignature()) //XXX addType not handling 						.addType(argType.getSignature())  //    generics properly						,sourceLineAnnotation);			}					}								accumulator.reportAccumulatedBugs();	}