Projects >> wala-mirror >>cdaaddf88b9ab1dda6b5bf859b38bca6055b057b

Chunk
Conflicting content 
        return null;
    }

<<<<<<< HEAD
=======
    @Override
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
    public CAstControlFlowMap getControlFlow() {
      Assertions.UNREACHABLE("CompilationUnitEntity.getControlFlow()");
      return null;
Solution content 
        return null;
    }

    @Override
    public CAstControlFlowMap getControlFlow() {
      Assertions.UNREACHABLE("CompilationUnitEntity.getControlFlow()");
      return null;
File
PolyglotJava2CAstTranslator.java
Developer's decision
Version 2
Kind of conflict
Annotation
Chunk
Conflicting content 
        return null;
    }

<<<<<<< HEAD
=======
    @Override
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
    public Map> getAllScopedEntities() {
      return Collections.singletonMap(null, fEntities);
    }
Solution content 
        return null;
    }

    @Override
    public Map> getAllScopedEntities() {
      return Collections.singletonMap(null, fEntities);
    }
File
PolyglotJava2CAstTranslator.java
Developer's decision
Version 2
Kind of conflict
Annotation
Chunk
Conflicting content 
        return null;
    }

<<<<<<< HEAD
=======
    @Override
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
    public CAstControlFlowMap getControlFlow() {
      // No AST for a field decl; initializers folded into
      // constructor processing...
Solution content 
        return null;
    }

    @Override
    public CAstControlFlowMap getControlFlow() {
      // No AST for a field decl; initializers folded into
      // constructor processing...
File
PolyglotJava2CAstTranslator.java
Developer's decision
Version 2
Kind of conflict
Annotation
Chunk
Conflicting content 
    public final Set classAnnotations = HashSetFactory.make();
    public final Set methodAnnotations = HashSetFactory.make();
    
<<<<<<< HEAD
=======
    @Override
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
    public void check(CallGraph cg) {
      classes: for(ClassAnnotation ca : classAnnotations) {
        IClass cls = cg.getClassHierarchy().lookupClass(TypeReference.findOrCreate(ClassLoaderReference.Application, ca.className));
Solution content 
    public final Set classAnnotations = HashSetFactory.make();
    public final Set methodAnnotations = HashSetFactory.make();
    
    @Override
    public void check(CallGraph cg) {
      classes: for(ClassAnnotation ca : classAnnotations) {
        IClass cls = cg.getClassHierarchy().lookupClass(TypeReference.findOrCreate(ClassLoaderReference.Application, ca.className));
File
IRTests.java
Developer's decision
Version 2
Kind of conflict
Annotation
Chunk
Conflicting content 
      this.annotations = annotations;
    }

<<<<<<< HEAD
=======
    @Override
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
    public Collection getAnnotations() {
      return annotations;
    }
Solution content 
      this.annotations = annotations;
    }

    @Override
    public Collection getAnnotations() {
      return annotations;
    }
File
JavaSourceLoaderImpl.java
Developer's decision
Version 2
Kind of conflict
Annotation
Chunk
Conflicting content 
      sb.append(getName().toString());
      if (enclosingClass != null) {
        sb.append(" (within " + enclosingClass.getName() + ")");
<<<<<<< HEAD
      }
      if (annotations != null && !annotations.isEmpty()) {
        for(Annotation a : annotations) {
          sb.append("[" + a.getType().getName().getClassName() + "]");
        }
      }
=======
      }
      if (annotations != null && !annotations.isEmpty()) {
        for(Annotation a : annotations) {
          sb.append("[" + a.getType().getName().getClassName() + "]");
        }
      }
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
      return sb.toString();
    }
  }
Solution content 
      sb.append(getName().toString());
      if (enclosingClass != null) {
        sb.append(" (within " + enclosingClass.getName() + ")");
      }
      if (annotations != null && !annotations.isEmpty()) {
        for(Annotation a : annotations) {
          sb.append("[" + a.getType().getName().getClassName() + "]");
        }
      }
      return sb.toString();
    }
  }
File
JavaSourceLoaderImpl.java
Developer's decision
Version 1
Kind of conflict
If statement
Chunk
Conflicting content 
    public JavaEntityMethod(CAstEntity methodEntity, IClass owner, AbstractCFG cfg, SymbolTable symtab, boolean hasCatchBlock,
        Map caughtTypes, boolean hasMonitorOp, AstLexicalInformation lexicalInfo, DebuggingInformation debugInfo) {
      super(owner, methodEntity.getQualifiers(), cfg, symtab, MethodReference.findOrCreate(owner.getReference(), Util
<<<<<<< HEAD
          .methodEntityToSelector(methodEntity)), hasCatchBlock, catchTypes, hasMonitorOp, lexicalInfo, debugInfo, JavaSourceLoaderImpl.this.getAnnotations(methodEntity));
=======
          .methodEntityToSelector(methodEntity)), hasCatchBlock, caughtTypes, hasMonitorOp, lexicalInfo, debugInfo, JavaSourceLoaderImpl.this.getAnnotations(methodEntity));
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
      this.parameterTypes = computeParameterTypes(methodEntity);
      this.exceptionTypes = computeExceptionTypes(methodEntity);
    }
Solution content 
    public JavaEntityMethod(CAstEntity methodEntity, IClass owner, AbstractCFG cfg, SymbolTable symtab, boolean hasCatchBlock,
        Map caughtTypes, boolean hasMonitorOp, AstLexicalInformation lexicalInfo, DebuggingInformation debugInfo) {
      super(owner, methodEntity.getQualifiers(), cfg, symtab, MethodReference.findOrCreate(owner.getReference(), Util
          .methodEntityToSelector(methodEntity)), hasCatchBlock, caughtTypes, hasMonitorOp, lexicalInfo, debugInfo, JavaSourceLoaderImpl.this.getAnnotations(methodEntity));
      this.parameterTypes = computeParameterTypes(methodEntity);
      this.exceptionTypes = computeExceptionTypes(methodEntity);
    }
File
JavaSourceLoaderImpl.java
Developer's decision
Version 2
Kind of conflict
Method invocation
Variable
Chunk
Conflicting content 
  }

  protected abstract SourceModuleTranslator getTranslator();
<<<<<<< HEAD
/** BEGIN Custom change: Optional deletion of fTypeMap */
  public static volatile boolean deleteTypeMapAfterInit = true;
/** END Custom change: Optional deletion of fTypeMap */
  
=======

  @Override
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
  public void init(List modules) throws IOException {
    super.init(modules);
/** BEGIN Custom change: Optional deletion of fTypeMap */
Solution content 
  }

  protected abstract SourceModuleTranslator getTranslator();
/** BEGIN Custom change: Optional deletion of fTypeMap */
  public static volatile boolean deleteTypeMapAfterInit = true;
/** END Custom change: Optional deletion of fTypeMap */
  

  @Override
  public void init(List modules) throws IOException {
    super.init(modules);
/** BEGIN Custom change: Optional deletion of fTypeMap */
File
JavaSourceLoaderImpl.java
Developer's decision
Concatenation
Kind of conflict
Annotation
Attribute
Comment
Chunk
Conflicting content 
  
  public static class InstructionFactory extends JavaInstructionFactory implements AstJavaInstructionFactory {

<<<<<<< HEAD
    public com.ibm.wala.cast.java.ssa.EnclosingObjectReference EnclosingObjectReference(int iindex, int lval, TypeReference type) {
      return new EnclosingObjectReference(iindex, lval, type);
    }

    public AstJavaNewEnclosingInstruction JavaNewEnclosingInstruction(int iindex, int result, NewSiteReference site, int enclosing) {
      return new AstJavaNewEnclosingInstruction(iindex, result, site, enclosing);
    }

    public AstJavaInvokeInstruction JavaInvokeInstruction(int iindex, int result, int[] params, int exception, CallSiteReference site) {
      return new AstJavaInvokeInstruction(result, params, exception, site);
    }

    public AstJavaInvokeInstruction JavaInvokeInstruction(int iindex, int[] params, int exception, CallSiteReference site) {
      return new AstJavaInvokeInstruction(iindex, params, exception, site);
    }

    public AstJavaInvokeInstruction JavaInvokeInstruction(int iindex, int[] results, int[] params, int exception, CallSiteReference site,
=======
    @Override
    public com.ibm.wala.cast.java.ssa.EnclosingObjectReference EnclosingObjectReference(int lval, TypeReference type) {
      return new EnclosingObjectReference(lval, type);
    }

    @Override
    public AstJavaNewEnclosingInstruction JavaNewEnclosingInstruction(int result, NewSiteReference site, int enclosing) {
      return new AstJavaNewEnclosingInstruction(result, site, enclosing);
    }

    @Override
    public AstJavaInvokeInstruction JavaInvokeInstruction(int result, int[] params, int exception, CallSiteReference site) {
      return new AstJavaInvokeInstruction(result, params, exception, site);
    }

    @Override
    public AstJavaInvokeInstruction JavaInvokeInstruction(int[] params, int exception, CallSiteReference site) {
      return new AstJavaInvokeInstruction(params, exception, site);
    }

    @Override
    public AstJavaInvokeInstruction JavaInvokeInstruction(int[] results, int[] params, int exception, CallSiteReference site,
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
        Access[] lexicalReads, Access[] lexicalWrites) {
      return new AstJavaInvokeInstruction(iindex, results, params, exception, site, lexicalReads, lexicalWrites);
    }
Solution content 
  
  public static class InstructionFactory extends JavaInstructionFactory implements AstJavaInstructionFactory {

    @Override
    public com.ibm.wala.cast.java.ssa.EnclosingObjectReference EnclosingObjectReference(int iindex, int lval, TypeReference type) {
      return new EnclosingObjectReference(iindex, lval, type);
    }

    @Override
    public AstJavaNewEnclosingInstruction JavaNewEnclosingInstruction(int iindex, int result, NewSiteReference site, int enclosing) {
      return new AstJavaNewEnclosingInstruction(iindex, result, site, enclosing);
    }

    @Override
    public AstJavaInvokeInstruction JavaInvokeInstruction(int iindex, int result, int[] params, int exception, CallSiteReference site) {
      return new AstJavaInvokeInstruction(iindex, result, params, exception, site);
    }

    @Override
    public AstJavaInvokeInstruction JavaInvokeInstruction(int iindex, int[] params, int exception, CallSiteReference site) {
      return new AstJavaInvokeInstruction(iindex, params, exception, site);
    }

    @Override
    public AstJavaInvokeInstruction JavaInvokeInstruction(int iindex, int[] results, int[] params, int exception, CallSiteReference site,
        Access[] lexicalReads, Access[] lexicalWrites) {
      return new AstJavaInvokeInstruction(iindex, results, params, exception, site, lexicalReads, lexicalWrites);
    }
File
JavaSourceLoaderImpl.java
Developer's decision
Manual
Kind of conflict
Annotation
Method declaration
Method signature
Chunk
Conflicting content 
      return new AstJavaInvokeInstruction(iindex, results, params, exception, site, lexicalReads, lexicalWrites);
    }

<<<<<<< HEAD
    public AstAssertInstruction AssertInstruction(int iindex, int value, boolean fromSpecification) {
      return new AstAssertInstruction(iindex, value, fromSpecification);
    }

    public com.ibm.wala.cast.ir.ssa.AssignInstruction AssignInstruction(int iindex, int result, int val) {
       return new AssignInstruction(iindex, result, val);
    }

    public com.ibm.wala.cast.ir.ssa.EachElementGetInstruction EachElementGetInstruction(int iindex, int value, int objectRef) {
      throw new UnsupportedOperationException();
    }

    public com.ibm.wala.cast.ir.ssa.EachElementHasNextInstruction EachElementHasNextInstruction(int iindex, int value, int objectRef) {
      throw new UnsupportedOperationException();
    }

    public AstEchoInstruction EchoInstruction(int iindex, int[] rvals) {
      throw new UnsupportedOperationException();
    }

    public AstGlobalRead GlobalRead(int iindex, int lhs, FieldReference global) {
      throw new UnsupportedOperationException();
    }

    public AstGlobalWrite GlobalWrite(int iindex, FieldReference global, int rhs) {
      throw new UnsupportedOperationException();
    }

    public AstIsDefinedInstruction IsDefinedInstruction(int iindex, int lval, int rval, int fieldVal, FieldReference fieldRef) {
      throw new UnsupportedOperationException();
    }

    public AstIsDefinedInstruction IsDefinedInstruction(int iindex, int lval, int rval, FieldReference fieldRef) {
      throw new UnsupportedOperationException();
    }

    public AstIsDefinedInstruction IsDefinedInstruction(int iindex, int lval, int rval, int fieldVal) {
      throw new UnsupportedOperationException();
    }

    public AstIsDefinedInstruction IsDefinedInstruction(int iindex, int lval, int rval) {
      throw new UnsupportedOperationException();
    }

    public AstLexicalRead LexicalRead(int iindex, Access[] accesses) {
      return new AstLexicalRead(iindex, accesses);
    }

    public AstLexicalRead LexicalRead(int iindex, Access access) {
       return new AstLexicalRead(iindex, access);
    }

    public AstLexicalRead LexicalRead(int iindex, int lhs, String definer, String globalName) {
      return new AstLexicalRead(iindex, lhs, definer, globalName);
    }

    public AstLexicalWrite LexicalWrite(int iindex, Access[] accesses) {
      return new AstLexicalWrite(iindex, accesses);
    }

    public AstLexicalWrite LexicalWrite(int iindex, Access access) {
      return new AstLexicalWrite(iindex, access);
    }

    public AstLexicalWrite LexicalWrite(int iindex, String definer, String globalName, int rhs) {
       return new AstLexicalWrite(iindex, definer, globalName, rhs);
=======
    @Override
    public AstAssertInstruction AssertInstruction(int value, boolean fromSpecification) {
      return new AstAssertInstruction(value, fromSpecification);
    }

    @Override
    public com.ibm.wala.cast.ir.ssa.AssignInstruction AssignInstruction(int result, int val) {
       return new AssignInstruction(result, val);
    }

    @Override
    public com.ibm.wala.cast.ir.ssa.EachElementGetInstruction EachElementGetInstruction(int value, int objectRef) {
      throw new UnsupportedOperationException();
    }

    @Override
    public com.ibm.wala.cast.ir.ssa.EachElementHasNextInstruction EachElementHasNextInstruction(int value, int objectRef) {
      throw new UnsupportedOperationException();
    }

    @Override
    public AstEchoInstruction EchoInstruction(int[] rvals) {
      throw new UnsupportedOperationException();
    }

    @Override
    public AstGlobalRead GlobalRead(int lhs, FieldReference global) {
      throw new UnsupportedOperationException();
    }

    @Override
    public AstGlobalWrite GlobalWrite(FieldReference global, int rhs) {
      throw new UnsupportedOperationException();
    }

    @Override
    public AstIsDefinedInstruction IsDefinedInstruction(int lval, int rval, int fieldVal, FieldReference fieldRef) {
      throw new UnsupportedOperationException();
    }

    @Override
    public AstIsDefinedInstruction IsDefinedInstruction(int lval, int rval, FieldReference fieldRef) {
      throw new UnsupportedOperationException();
    }

    @Override
    public AstIsDefinedInstruction IsDefinedInstruction(int lval, int rval, int fieldVal) {
      throw new UnsupportedOperationException();
    }

    @Override
    public AstIsDefinedInstruction IsDefinedInstruction(int lval, int rval) {
      throw new UnsupportedOperationException();
    }

    @Override
    public AstLexicalRead LexicalRead(Access[] accesses) {
      return new AstLexicalRead(accesses);
    }

    @Override
    public AstLexicalRead LexicalRead(Access access) {
       return new AstLexicalRead(access);
    }

    @Override
    public AstLexicalRead LexicalRead(int lhs, String definer, String globalName) {
      return new AstLexicalRead(lhs, definer, globalName);
    }

    @Override
    public AstLexicalWrite LexicalWrite(Access[] accesses) {
      return new AstLexicalWrite(accesses);
    }

    @Override
    public AstLexicalWrite LexicalWrite(Access access) {
      return new AstLexicalWrite(access);
    }

    @Override
    public AstLexicalWrite LexicalWrite(String definer, String globalName, int rhs) {
       return new AstLexicalWrite(definer, globalName, rhs);
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
    }

    public SSAThrowInstruction NonExceptingThrowInstruction(int iindex, int exception) {
Solution content 
      return new AstJavaInvokeInstruction(iindex, results, params, exception, site, lexicalReads, lexicalWrites);
    }

    @Override
    public AstAssertInstruction AssertInstruction(int iindex, int value, boolean fromSpecification) {
      return new AstAssertInstruction(iindex, value, fromSpecification);
    }

    @Override
    public com.ibm.wala.cast.ir.ssa.AssignInstruction AssignInstruction(int iindex, int result, int val) {
       return new AssignInstruction(iindex, result, val);
    }

    @Override
    public com.ibm.wala.cast.ir.ssa.EachElementGetInstruction EachElementGetInstruction(int iindex, int value, int objectRef) {
      throw new UnsupportedOperationException();
    }

    @Override
    public com.ibm.wala.cast.ir.ssa.EachElementHasNextInstruction EachElementHasNextInstruction(int iindex, int value, int objectRef) {
      throw new UnsupportedOperationException();
    }

    @Override
    public AstEchoInstruction EchoInstruction(int iindex, int[] rvals) {
      throw new UnsupportedOperationException();
    }

    @Override
    public AstGlobalRead GlobalRead(int iindex, int lhs, FieldReference global) {
      throw new UnsupportedOperationException();
    }

    @Override
    public AstGlobalWrite GlobalWrite(int iindex, FieldReference global, int rhs) {
      throw new UnsupportedOperationException();
    }

    @Override
    public AstIsDefinedInstruction IsDefinedInstruction(int iindex, int lval, int rval, int fieldVal, FieldReference fieldRef) {
      throw new UnsupportedOperationException();
    }

    @Override
    public AstIsDefinedInstruction IsDefinedInstruction(int iindex, int lval, int rval, FieldReference fieldRef) {
      throw new UnsupportedOperationException();
    }

    @Override
    public AstIsDefinedInstruction IsDefinedInstruction(int iindex, int lval, int rval, int fieldVal) {
      throw new UnsupportedOperationException();
    }

    @Override
    public AstIsDefinedInstruction IsDefinedInstruction(int iindex, int lval, int rval) {
      throw new UnsupportedOperationException();
    }

    @Override
    public AstLexicalRead LexicalRead(int iindex, Access[] accesses) {
      return new AstLexicalRead(iindex, accesses);
    }

    @Override
    public AstLexicalRead LexicalRead(int iindex, Access access) {
       return new AstLexicalRead(iindex, access);
    }

    @Override
    public AstLexicalRead LexicalRead(int iindex, int lhs, String definer, String globalName) {
      return new AstLexicalRead(iindex, lhs, definer, globalName);
    }

    @Override
    public AstLexicalWrite LexicalWrite(int iindex, Access[] accesses) {
      return new AstLexicalWrite(iindex, accesses);
    }

    @Override
    public AstLexicalWrite LexicalWrite(int iindex, Access access) {
      return new AstLexicalWrite(iindex, access);
    }

    @Override
    public AstLexicalWrite LexicalWrite(int iindex, String definer, String globalName, int rhs) {
       return new AstLexicalWrite(iindex, definer, globalName, rhs);
    }

    public SSAThrowInstruction NonExceptingThrowInstruction(int iindex, int exception) {
File
JavaSourceLoaderImpl.java
Developer's decision
Combination
Kind of conflict
Annotation
Method declaration
Method invocation
Method signature
Return statement
Chunk
Conflicting content 
	  JSCallGraphBuilderUtil.makeScriptCG("tests", "non_loop_break.js");
  }
  
<<<<<<< HEAD
  @Test(expected = AssertionError.class)
  public void testParseError() throws IllegalArgumentException, IOException, CancelException {
=======
  @Test(expected = WalaException.class)
  public void testParseError() throws IllegalArgumentException, IOException, CancelException, WalaException {
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
    PropagationCallGraphBuilder B = JSCallGraphBuilderUtil.makeScriptCGBuilder("tests", "portal-example-simple.html");
    B.makeCallGraph(B.getOptions());
    Util.checkForFrontEndErrors(B.getClassHierarchy());
Solution content 
	  JSCallGraphBuilderUtil.makeScriptCG("tests", "non_loop_break.js");
  }
  
  @Test(expected = WalaException.class)
  public void testParseError() throws IllegalArgumentException, IOException, CancelException, WalaException {
    PropagationCallGraphBuilder B = JSCallGraphBuilderUtil.makeScriptCGBuilder("tests", "portal-example-simple.html");
    B.makeCallGraph(B.getOptions());
    Util.checkForFrontEndErrors(B.getClassHierarchy());
File
TestSimpleCallGraphShapeRhino.java
Developer's decision
Version 2
Kind of conflict
Annotation
Method signature
Chunk
Conflicting content 
		verifyGraphAssertions(CG, assertionsForPage3);
	}

<<<<<<< HEAD
	@Test(expected = AssertionError.class)
	public void testJSParseError() throws IOException, IllegalArgumentException, CancelException {
=======
	@Test(expected = WalaException.class)
	public void testJSParseError() throws IOException, IllegalArgumentException, CancelException, WalaException {
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
		URL url = getClass().getClassLoader().getResource("pages/garbage2.html");
		JSCFABuilder B = JSCallGraphBuilderUtil.makeHTMLCGBuilder(url);
		B.makeCallGraph(B.getOptions());
Solution content 
		verifyGraphAssertions(CG, assertionsForPage3);
	}

	@Test(expected = WalaException.class)
	public void testJSParseError() throws IOException, IllegalArgumentException, CancelException, WalaException {
		URL url = getClass().getClassLoader().getResource("pages/garbage2.html");
		JSCFABuilder B = JSCallGraphBuilderUtil.makeHTMLCGBuilder(url);
		B.makeCallGraph(B.getOptions());
File
TestSimplePageCallGraphShapeRhino.java
Developer's decision
Version 2
Kind of conflict
Annotation
Method signature
Chunk
Conflicting content 
		verifyGraphAssertions(CG, null);
	}

<<<<<<< HEAD
	@Test public void testParseError() throws IOException, IllegalArgumentException, CancelException {
=======
	@Test public void testParseError() throws IOException, IllegalArgumentException, CancelException, WalaException {
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
		URL url = getClass().getClassLoader().getResource("pages/garbage.html");
		JSCFABuilder B = JSCallGraphBuilderUtil.makeHTMLCGBuilder(url);
		B.makeCallGraph(B.getOptions());
Solution content 
		verifyGraphAssertions(CG, null);
	}

	@Test public void testParseError() throws IOException, IllegalArgumentException, CancelException, WalaException {
		URL url = getClass().getClassLoader().getResource("pages/garbage.html");
		JSCFABuilder B = JSCallGraphBuilderUtil.makeHTMLCGBuilder(url);
		B.makeCallGraph(B.getOptions());
File
TestSimplePageCallGraphShapeRhinoJericho.java
Developer's decision
Version 2
Kind of conflict
Method signature
Chunk
Conflicting content 
import com.ibm.wala.util.WalaException;

public class JsViewerDriver extends JSCallGraphBuilderUtil {
<<<<<<< HEAD
	public static void main(String args[]) throws ClassHierarchyException, IllegalArgumentException, IOException, CancelException, Error {
=======
	public static void main(String args[]) throws ClassHierarchyException, IllegalArgumentException, IOException, CancelException, Error, WalaException {
>>>>>>> b984760100e3be325d458f61b0d556f479701c95

		if (args.length != 1){
			System.out.println("Usage: ");
Solution content 
import com.ibm.wala.util.WalaException;

public class JsViewerDriver extends JSCallGraphBuilderUtil {
	public static void main(String args[]) throws ClassHierarchyException, IllegalArgumentException, IOException, CancelException, Error, WalaException {

		if (args.length != 1){
			System.out.println("Usage: ");
File
JsViewerDriver.java
Developer's decision
Version 2
Kind of conflict
Method signature
Chunk
Conflicting content 
      rewriters.add(factory);
  }  

<<<<<<< HEAD
=======
  @Override
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
  public CAstEntity translateToCAst() throws IOException, Error {
    String N;
    if (M instanceof SourceFileModule) {
Solution content 
      rewriters.add(factory);
  }  

  @Override
  public CAstEntity translateToCAst() throws IOException, Error {
    String N;
    if (M instanceof SourceFileModule) {
File
CAstRhinoTranslator.java
Developer's decision
Version 2
Kind of conflict
Annotation
Chunk
Conflicting content 
import com.ibm.wala.cast.js.loader.JavaScriptLoader;
import com.ibm.wala.cast.js.loader.JavaScriptLoaderFactory;
import com.ibm.wala.cast.loader.CAstAbstractLoader;
<<<<<<< HEAD
=======
import com.ibm.wala.cast.tree.rewrite.CAstRewriterFactory;
import com.ibm.wala.classLoader.IMethod;
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
import com.ibm.wala.classLoader.SourceFileModule;
import com.ibm.wala.classLoader.SourceModule;
import com.ibm.wala.classLoader.SourceURLModule;
Solution content 
import com.ibm.wala.cast.js.loader.JavaScriptLoader;
import com.ibm.wala.cast.js.loader.JavaScriptLoaderFactory;
import com.ibm.wala.cast.loader.CAstAbstractLoader;
import com.ibm.wala.cast.tree.rewrite.CAstRewriterFactory;
import com.ibm.wala.classLoader.IMethod;
import com.ibm.wala.classLoader.SourceFileModule;
import com.ibm.wala.classLoader.SourceModule;
import com.ibm.wala.classLoader.SourceURLModule;
File
JSCallGraphBuilderUtil.java
Developer's decision
Version 2
Kind of conflict
Import
Chunk
Conflicting content 
  public static JSCFABuilder makeHTMLCGBuilder(URL url, CGBuilderType builderType) throws IOException, WalaException {
    JavaScriptLoader.addBootstrapFile(WebUtil.preamble);
    SourceModule[] scripts;
<<<<<<< HEAD
    IRFactory irFactory = AstIRFactory.makeDefaultFactory();
    JavaScriptLoaderFactory loaders = new WebPageLoaderFactory(translatorFactory, preprocessor);
    try {
      Set script = WebUtil.extractScriptFromHTML(url);
=======
    IRFactory irFactory = AstIRFactory.makeDefaultFactory();
    CAstRewriterFactory preprocessor = builderType.extractCorrelatedPairs ? new CorrelatedPairExtractorFactory(translatorFactory, url) : null;
    JavaScriptLoaderFactory loaders = new WebPageLoaderFactory(translatorFactory, preprocessor);
    try {
      Set script = WebUtil.extractScriptFromHTML(url).fst;
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
      scripts = script.toArray(new SourceModule[script.size()]);
    } catch (Error e) {
      SourceModule dummy = new SourceURLModule(url);
Solution content 
  public static JSCFABuilder makeHTMLCGBuilder(URL url, CGBuilderType builderType) throws IOException, WalaException {
    JavaScriptLoader.addBootstrapFile(WebUtil.preamble);
    SourceModule[] scripts;
    IRFactory irFactory = AstIRFactory.makeDefaultFactory();
    CAstRewriterFactory preprocessor = builderType.extractCorrelatedPairs ? new CorrelatedPairExtractorFactory(translatorFactory, url) : null;
    JavaScriptLoaderFactory loaders = new WebPageLoaderFactory(translatorFactory, preprocessor);
    try {
      Set script = WebUtil.extractScriptFromHTML(url).fst;
      scripts = script.toArray(new SourceModule[script.size()]);
    } catch (Error e) {
      SourceModule dummy = new SourceURLModule(url);
File
JSCallGraphBuilderUtil.java
Developer's decision
Version 2
Kind of conflict
Attribute
Method invocation
Try statement
Variable
Chunk
Conflicting content 
      ((CAstAbstractLoader)loaders.getTheLoader()).addMessage(dummy, e.warning);
    }
    JSCFABuilder builder = makeCGBuilder(loaders, scripts, builderType, irFactory);
<<<<<<< HEAD
=======
    if(builderType.extractCorrelatedPairs)
      builder.setContextSelector(new PropertyNameContextSelector(builder.getAnalysisCache(), 2, builder.getContextSelector()));
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
    builder.setBaseURL(url);
    return builder;
  }
Solution content 
      ((CAstAbstractLoader)loaders.getTheLoader()).addMessage(dummy, e.warning);
    }
    JSCFABuilder builder = makeCGBuilder(loaders, scripts, builderType, irFactory);
    if(builderType.extractCorrelatedPairs)
      builder.setContextSelector(new PropertyNameContextSelector(builder.getAnalysisCache(), 2, builder.getContextSelector()));
    builder.setBaseURL(url);
    return builder;
  }
File
JSCallGraphBuilderUtil.java
Developer's decision
Version 2
Kind of conflict
If statement
Chunk
Conflicting content 
import org.junit.Test;

import com.ibm.wala.cast.ipa.callgraph.CAstCallGraphUtil;
<<<<<<< HEAD
import com.ibm.wala.cast.js.ipa.callgraph.ForInContextSelector;
import com.ibm.wala.cast.js.ipa.callgraph.JSCFABuilder;
import com.ibm.wala.cast.js.ipa.callgraph.JSCallGraphUtil;
import com.ibm.wala.cast.js.util.Util;
=======
import com.ibm.wala.cast.js.ipa.callgraph.JSCFABuilder;
import com.ibm.wala.cast.js.ipa.callgraph.JSCallGraphUtil;
import com.ibm.wala.cast.js.ipa.callgraph.PropertyNameContextSelector;
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
import com.ibm.wala.ipa.callgraph.CGNode;
import com.ibm.wala.ipa.callgraph.CallGraph;
import com.ibm.wala.ipa.callgraph.CallGraphBuilderCancelException;
Solution content 
import org.junit.Test;

import com.ibm.wala.cast.ipa.callgraph.CAstCallGraphUtil;
import com.ibm.wala.cast.js.ipa.callgraph.JSCFABuilder;
import com.ibm.wala.cast.js.ipa.callgraph.JSCallGraphUtil;
import com.ibm.wala.cast.js.ipa.callgraph.PropertyNameContextSelector;
import com.ibm.wala.ipa.callgraph.CGNode;
import com.ibm.wala.ipa.callgraph.CallGraph;
import com.ibm.wala.ipa.callgraph.CallGraphBuilderCancelException;
File
TestSimpleCallGraphShape.java
Developer's decision
Version 2
Kind of conflict
Import
Chunk
Conflicting content 
  };

    @Test
<<<<<<< HEAD
  public void testDateAsProperty() throws IllegalArgumentException, IOException, CancelException {
=======
  public void testDateAsProperty() throws IllegalArgumentException, IOException, CancelException, WalaException {
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
    PropagationCallGraphBuilder B = JSCallGraphBuilderUtil.makeScriptCGBuilder("tests", "date-property.js");
    CallGraph CG = B.makeCallGraph(B.getOptions());
    //JSCallGraphUtil.AVOID_DUMP = false;
Solution content 
  };

    @Test
  public void testDateAsProperty() throws IllegalArgumentException, IOException, CancelException, WalaException {
    PropagationCallGraphBuilder B = JSCallGraphBuilderUtil.makeScriptCGBuilder("tests", "date-property.js");
    CallGraph CG = B.makeCallGraph(B.getOptions());
    //JSCallGraphUtil.AVOID_DUMP = false;
File
TestSimpleCallGraphShape.java
Developer's decision
Version 2
Kind of conflict
Method signature
Chunk
Conflicting content 
    //JSCallGraphUtil.dumpCG(B.getPointerAnalysis(), CG);
    verifyGraphAssertions(CG, assertionsForDateProperty);
  }
<<<<<<< HEAD
  
=======
    private static final Object[][] assertionsForDeadCode = new Object[][] {
      new Object[] { ROOT, new String[] { "tests/dead.js" } },
      new Object[] { "tests/dead.js", new String[] { "suffix:twoReturns" } }
    };

    @Test
    public void testDeadCode() throws IllegalArgumentException, IOException, CancelException, WalaException {
      PropagationCallGraphBuilder B = JSCallGraphBuilderUtil.makeScriptCGBuilder("tests", "dead.js");
      CallGraph CG = B.makeCallGraph(B.getOptions());
      //JSCallGraphUtil.AVOID_DUMP = false;
      //JSCallGraphUtil.dumpCG(B.getPointerAnalysis(), CG);
      verifyGraphAssertions(CG, assertionsForDeadCode);
    }
    
    private static final Object[][] assertionsForExtend = new Object[][] {
      new Object[] { ROOT, new String[] { "tests/extend.js" } },
      new Object[] { "tests/extend.js", new String[] { "suffix:bar", "!suffix:foo" } }
    };
    
    @Test
    public void testExtend() throws IOException, WalaException, IllegalArgumentException, CancelException {
      JSCFABuilder builder = JSCallGraphBuilderUtil.makeScriptCGBuilder("tests", "extend.js");
      CallGraph cg = builder.makeCallGraph(builder.getOptions());
      verifyGraphAssertions(cg, assertionsForExtend);
    }

    @Test
    public void testDeadCatch() throws IllegalArgumentException, IOException, CancelException, WalaException {
      JSCallGraphBuilderUtil.makeScriptCG("tests", "dead_catch.js");
    }

    @Ignore("need a bug fix")
    @Test
    public void testTryFinallyCrash() throws IllegalArgumentException, IOException, CancelException, WalaException {      
      JSCallGraphBuilderUtil.makeScriptCG("tests", "try-finally-crash.js");
    }


    @Test(expected = CallGraphBuilderCancelException.class)
    public void testManyStrings() throws IllegalArgumentException, IOException, CancelException, WalaException {
      SSAPropagationCallGraphBuilder B = JSCallGraphBuilderUtil.makeScriptCGBuilder("tests", "many-strings.js");
      B.getOptions().setTraceStringConstants(true);
      final long startTime = System.currentTimeMillis();
      CallGraph CG = B.makeCallGraph(B.getOptions(), new IProgressMonitor() {
        @Override
        public void beginTask(String task, int totalWork) {
        }
        @Override
        public boolean isCanceled() {
           return System.currentTimeMillis() > (startTime + 10000L);
        }
        @Override
        public void done() {
        }
        @Override
        public void worked(int units) {
        }
      });
      CAstCallGraphUtil.dumpCG(B.getPointerAnalysis(), CG);
    }

    @Test
  public void testTutorialExample() throws IllegalArgumentException, IOException, CancelException, WalaException {
    PropagationCallGraphBuilder B = JSCallGraphBuilderUtil.makeScriptCGBuilder("tests", "tutorial-example.js");
    CallGraph CG = B.makeCallGraph(B.getOptions());
    CAstCallGraphUtil.dumpCG(B.getPointerAnalysis(), CG);
    // verifyGraphAssertions(CG, assertionsForDateProperty);
  }

>>>>>>> b984760100e3be325d458f61b0d556f479701c95
  protected IVector>> computeIkIdToVns(PointerAnalysis pa) {

    // Created by reversing the points to mapping for local pointer keys.
Solution content 
    //JSCallGraphUtil.dumpCG(B.getPointerAnalysis(), CG);
    verifyGraphAssertions(CG, assertionsForDateProperty);
  }
    private static final Object[][] assertionsForDeadCode = new Object[][] {
      new Object[] { ROOT, new String[] { "tests/dead.js" } },
      new Object[] { "tests/dead.js", new String[] { "suffix:twoReturns" } }
    };

    @Test
    public void testDeadCode() throws IllegalArgumentException, IOException, CancelException, WalaException {
      PropagationCallGraphBuilder B = JSCallGraphBuilderUtil.makeScriptCGBuilder("tests", "dead.js");
      CallGraph CG = B.makeCallGraph(B.getOptions());
      //JSCallGraphUtil.AVOID_DUMP = false;
      //JSCallGraphUtil.dumpCG(B.getPointerAnalysis(), CG);
      verifyGraphAssertions(CG, assertionsForDeadCode);
    }
    
    private static final Object[][] assertionsForExtend = new Object[][] {
      new Object[] { ROOT, new String[] { "tests/extend.js" } },
      new Object[] { "tests/extend.js", new String[] { "suffix:bar", "!suffix:foo" } }
    };
    
    @Test
    public void testExtend() throws IOException, WalaException, IllegalArgumentException, CancelException {
      JSCFABuilder builder = JSCallGraphBuilderUtil.makeScriptCGBuilder("tests", "extend.js");
      CallGraph cg = builder.makeCallGraph(builder.getOptions());
      verifyGraphAssertions(cg, assertionsForExtend);
    }

    @Test
    public void testDeadCatch() throws IllegalArgumentException, IOException, CancelException, WalaException {
      JSCallGraphBuilderUtil.makeScriptCG("tests", "dead_catch.js");
    }

    @Ignore("need a bug fix")
    @Test
    public void testTryFinallyCrash() throws IllegalArgumentException, IOException, CancelException, WalaException {      
      JSCallGraphBuilderUtil.makeScriptCG("tests", "try-finally-crash.js");
    }


    @Test(expected = CallGraphBuilderCancelException.class)
    public void testManyStrings() throws IllegalArgumentException, IOException, CancelException, WalaException {
      SSAPropagationCallGraphBuilder B = JSCallGraphBuilderUtil.makeScriptCGBuilder("tests", "many-strings.js");
      B.getOptions().setTraceStringConstants(true);
      final long startTime = System.currentTimeMillis();
      CallGraph CG = B.makeCallGraph(B.getOptions(), new IProgressMonitor() {
        @Override
        public void beginTask(String task, int totalWork) {
        }
        @Override
        public boolean isCanceled() {
           return System.currentTimeMillis() > (startTime + 10000L);
        }
        @Override
        public void done() {
        }
        @Override
        public void worked(int units) {
        }
        public void subTask(String subTask) {
        }
        public void cancel() {
        }
      });
      CAstCallGraphUtil.dumpCG(B.getPointerAnalysis(), CG);
    }

    @Test
  public void testTutorialExample() throws IllegalArgumentException, IOException, CancelException, WalaException {
    PropagationCallGraphBuilder B = JSCallGraphBuilderUtil.makeScriptCGBuilder("tests", "tutorial-example.js");
    CallGraph CG = B.makeCallGraph(B.getOptions());
    CAstCallGraphUtil.dumpCG(B.getPointerAnalysis(), CG);
    // verifyGraphAssertions(CG, assertionsForDateProperty);
  }

  protected IVector>> computeIkIdToVns(PointerAnalysis pa) {

    // Created by reversing the points to mapping for local pointer keys.
File
TestSimpleCallGraphShape.java
Developer's decision
Manual
Kind of conflict
Annotation
Attribute
Method declaration
Method invocation
Chunk
Conflicting content 
  public static boolean USE_TEMP_NAME = true;

  public abstract Set extractSources(URL entrypointUrl, IHtmlParser htmlParser, IUrlResolver urlResolver) throws IOException, Error;
<<<<<<< HEAD
=======
  
  /**
   * Returns the temporary file created by a call to
   * {@link #extractSources(URL, IHtmlParser, IUrlResolver)} which holds all the
   * discovered JS source. If no such file exists, returns null
   */
  public abstract File getTempFile();
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
  
}
Solution content 
  public static boolean USE_TEMP_NAME = true;

  public abstract Set extractSources(URL entrypointUrl, IHtmlParser htmlParser, IUrlResolver urlResolver) throws IOException, Error;
  
  /**
   * Returns the temporary file created by a call to
   * {@link #extractSources(URL, IHtmlParser, IUrlResolver)} which holds all the
   * discovered JS source. If no such file exists, returns null
   */
  public abstract File getTempFile();
  
}
File
JSSourceExtractor.java
Developer's decision
Version 2
Kind of conflict
Comment
Method interface
Chunk
Conflicting content 
import com.ibm.wala.cast.ir.translator.TranslatorToCAst.Error;
import com.ibm.wala.cast.js.html.jericho.JerichoHtmlParser;
<<<<<<< HEAD
=======
import com.ibm.wala.util.collections.Pair;
>>>>>>> b984760100e3be325d458f61b0d556f479701c95

public class WebUtil {
Solution content 
import com.ibm.wala.cast.ir.translator.TranslatorToCAst.Error;
import com.ibm.wala.cast.js.html.jericho.JerichoHtmlParser;
import com.ibm.wala.util.collections.Pair;

public class WebUtil {
File
WebUtil.java
Developer's decision
Version 2
Kind of conflict
Import
Chunk
Conflicting content 
    WebUtil.factory = factory;
  }

<<<<<<< HEAD
  public static Set extractScriptFromHTML(URL url) throws Error {
=======
  /**
   * 
   * @param url
   * @return a pair (S,F), where S is a set of extracted sources, and F is the
   *         temp file holding the combined sources (or null if no
   *         such file exists)
   * @throws Error
   */
  public static Pair,File> extractScriptFromHTML(URL url) throws Error {
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
    try {
      JSSourceExtractor extractor = new DefaultSourceExtractor();
      Set sources = extractor.extractSources(url, factory.getParser(), new IdentityUrlResolver());
Solution content 
    WebUtil.factory = factory;
  }

  /**
   * 
   * @param url
   * @return a pair (S,F), where S is a set of extracted sources, and F is the
   *         temp file holding the combined sources (or null if no
   *         such file exists)
   * @throws Error
   */
  public static Pair,File> extractScriptFromHTML(URL url) throws Error {
    try {
      JSSourceExtractor extractor = new DefaultSourceExtractor();
      Set sources = extractor.extractSources(url, factory.getParser(), new IdentityUrlResolver());
File
WebUtil.java
Developer's decision
Version 2
Kind of conflict
Comment
Method signature
Chunk
Conflicting content 
      Config.LoggerProvider = new CAstLoggerProvider();
    }

<<<<<<< HEAD
	public void parse(URL url, InputStream reader, IHtmlCallback callback, String fileName) throws TranslatorToCAst.Error {
=======
	@Override
  public void parse(URL url, InputStream reader, IHtmlCallback callback, String fileName) throws TranslatorToCAst.Error {
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
	  warnings.clear();
		Parser parser = new Parser(callback, fileName);
		Source src;
Solution content 
	@Override
      Config.LoggerProvider = new CAstLoggerProvider();
    }

  public void parse(URL url, InputStream reader, IHtmlCallback callback, String fileName) throws TranslatorToCAst.Error {
	  warnings.clear();
		Parser parser = new Parser(callback, fileName);
		Source src;
File
JerichoHtmlParser.java
Developer's decision
Version 2
Kind of conflict
Annotation
Method signature
Chunk
Conflicting content 
       * All values used as property names get implicitly converted to strings in JavaScript.
       * @see com.ibm.wala.cast.ipa.callgraph.DelegatingAstPointerKeys#getFieldNameType(com.ibm.wala.ipa.callgraph.propagation.InstanceKey)
       */
<<<<<<< HEAD
=======
      @Override
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
      protected IClass getFieldNameType(InstanceKey F) {
        return F.getConcreteType().getClassHierarchy().lookupClass(JavaScriptTypes.String);
      }
Solution content 
       * All values used as property names get implicitly converted to strings in JavaScript.
       * @see com.ibm.wala.cast.ipa.callgraph.DelegatingAstPointerKeys#getFieldNameType(com.ibm.wala.ipa.callgraph.propagation.InstanceKey)
       */
      @Override
      protected IClass getFieldNameType(InstanceKey F) {
        return F.getConcreteType().getClassHierarchy().lookupClass(JavaScriptTypes.String);
      }
File
JSCFABuilder.java
Developer's decision
Version 2
Kind of conflict
Annotation
Chunk
Conflicting content 
    assert f != null : "couldn't resolve " + varName;
    return getPointerKeyForInstanceField(globalObject, f);
  }
<<<<<<< HEAD
=======
  @Override
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
  protected ExplicitCallGraph createEmptyCallGraph(IClassHierarchy cha, AnalysisOptions options) {
    return new JSCallGraph(cha, options, getAnalysisCache());
  }
Solution content 
    assert f != null : "couldn't resolve " + varName;
    return getPointerKeyForInstanceField(globalObject, f);
  }
  @Override
  protected ExplicitCallGraph createEmptyCallGraph(IClassHierarchy cha, AnalysisOptions options) {
    return new JSCallGraph(cha, options, getAnalysisCache());
  }
File
JSSSAPropagationCallGraphBuilder.java
Developer's decision
Version 2
Kind of conflict
Annotation
Chunk
Conflicting content 
import com.ibm.wala.cast.ir.ssa.AbstractReflectivePut;
import com.ibm.wala.cast.ir.ssa.AstIRFactory;
import com.ibm.wala.cast.ir.translator.TranslatorToCAst.Error;
<<<<<<< HEAD
import com.ibm.wala.cast.js.html.WebPageLoaderFactory;
=======
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
import com.ibm.wala.cast.js.html.WebUtil;
import com.ibm.wala.cast.js.ipa.callgraph.JSCallGraphUtil;
import com.ibm.wala.cast.js.loader.JavaScriptLoader;
Solution content 
import com.ibm.wala.cast.ir.ssa.AbstractReflectivePut;
import com.ibm.wala.cast.ir.ssa.AstIRFactory;
import com.ibm.wala.cast.ir.translator.TranslatorToCAst.Error;
import com.ibm.wala.cast.js.html.WebUtil;
import com.ibm.wala.cast.js.ipa.callgraph.JSCallGraphUtil;
import com.ibm.wala.cast.js.loader.JavaScriptLoader;
File
CorrelationFinder.java
Developer's decision
Version 2
Kind of conflict
Import
Chunk
Conflicting content 
  }

  public Map findCorrelatedAccesses(URL url) throws IOException, ClassHierarchyException {
<<<<<<< HEAD
    JavaScriptLoader.addBootstrapFile(WebUtil.preamble);
    Set script = null;
    try {
      script = WebUtil.extractScriptFromHTML(url);
    } catch (Error e) {
      assert false : e.warning;
    }
    Map summaries = findCorrelatedAccesses(script);
=======
    Set scripts = null;
    if(url.getPath().endsWith(".js")) {
      scripts = Collections.singleton(new SourceURLModule(url));
    } else {
      JavaScriptLoader.addBootstrapFile(WebUtil.preamble);
      try {
        scripts = WebUtil.extractScriptFromHTML(url).fst;
      } catch (Error e) {
        e.printStackTrace();
        assert false : e.warning;
      }
    }
    Map summaries = findCorrelatedAccesses(scripts);
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
    return summaries;
  }
Solution content 
  }

  public Map findCorrelatedAccesses(URL url) throws IOException, ClassHierarchyException {
    Set scripts = null;
    if(url.getPath().endsWith(".js")) {
      scripts = Collections.singleton(new SourceURLModule(url));
    } else {
      JavaScriptLoader.addBootstrapFile(WebUtil.preamble);
      try {
        scripts = WebUtil.extractScriptFromHTML(url).fst;
      } catch (Error e) {
        e.printStackTrace();
        assert false : e.warning;
      }
    }
    Map summaries = findCorrelatedAccesses(scripts);
    return summaries;
  }
File
CorrelationFinder.java
Developer's decision
Version 2
Kind of conflict
If statement
Method invocation
Try statement
Variable
Chunk
Conflicting content 
    public JSInstructionFactory instructionFactory() {
      return new JSInstructionFactory() {

<<<<<<< HEAD
        public JavaScriptCheckReference CheckReference(int iindex, int ref) {
          return new JavaScriptCheckReference(iindex, ref);
        }

        public SSAGetInstruction GetInstruction(int iindex, int result, int ref, String field) {
          return GetInstruction(iindex, result, ref, 
              FieldReference.findOrCreate(JavaScriptTypes.Root, Atom.findOrCreateUnicodeAtom(field), JavaScriptTypes.Root));
        }

        public JavaScriptInstanceOf InstanceOf(int iindex, int result, int objVal, int typeVal) {
          return new JavaScriptInstanceOf(iindex, result, objVal, typeVal);
        }

        public JavaScriptInvoke Invoke(int iindex, int function, int[] results, int[] params, int exception, CallSiteReference site) {
          return new JavaScriptInvoke(iindex, function, results, params, exception, site);
        }

        public JavaScriptInvoke Invoke(int iindex, int function, int[] results, int[] params, int exception, CallSiteReference site,
=======
        @Override
        public JavaScriptCheckReference CheckReference(int ref) {
          return new JavaScriptCheckReference(ref);
        }

        @Override
        public SSAGetInstruction GetInstruction(int result, int ref, String field) {
          return GetInstruction(result, ref,
              FieldReference.findOrCreate(JavaScriptTypes.Root, Atom.findOrCreateUnicodeAtom(field), JavaScriptTypes.Root));
        }

        @Override
        public JavaScriptInstanceOf InstanceOf(int result, int objVal, int typeVal) {
          return new JavaScriptInstanceOf(result, objVal, typeVal);
        }

        @Override
        public JavaScriptInvoke Invoke(int function, int[] results, int[] params, int exception, CallSiteReference site) {
          return new JavaScriptInvoke(function, results, params, exception, site);
        }

        @Override
        public JavaScriptInvoke Invoke(int function, int[] results, int[] params, int exception, CallSiteReference site,
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
            Access[] lexicalReads, Access[] lexicalWrites) {
          return new JavaScriptInvoke(iindex, function, results, params, exception, site, lexicalReads, lexicalWrites);
        }
Solution content 
    public JSInstructionFactory instructionFactory() {
      return new JSInstructionFactory() {

        @Override
        public JavaScriptCheckReference CheckReference(int iindex, int ref) {
          return new JavaScriptCheckReference(iindex, ref);
        }

        @Override
        public SSAGetInstruction GetInstruction(int iindex, int result, int ref, String field) {
          return GetInstruction(iindex, result, ref,
              FieldReference.findOrCreate(JavaScriptTypes.Root, Atom.findOrCreateUnicodeAtom(field), JavaScriptTypes.Root));
        }

        @Override
        public JavaScriptInstanceOf InstanceOf(int iindex, int result, int objVal, int typeVal) {
          return new JavaScriptInstanceOf(iindex, result, objVal, typeVal);
        }

        @Override
        public JavaScriptInvoke Invoke(int iindex, int function, int[] results, int[] params, int exception, CallSiteReference site) {
          return new JavaScriptInvoke(iindex, function, results, params, exception, site);
        }

        @Override
        public JavaScriptInvoke Invoke(int iindex, int function, int[] results, int[] params, int exception, CallSiteReference site,
            Access[] lexicalReads, Access[] lexicalWrites) {
          return new JavaScriptInvoke(iindex, function, results, params, exception, site, lexicalReads, lexicalWrites);
        }
File
JavaScriptLoader.java
Developer's decision
Combination
Kind of conflict
Annotation
Method declaration
Method signature
Chunk
Conflicting content 
          return new JavaScriptInvoke(iindex, function, results, params, exception, site, lexicalReads, lexicalWrites);
        }

<<<<<<< HEAD
        public JavaScriptInvoke Invoke(int iindex, int function, int result, int[] params, int exception, CallSiteReference site) {
          return new JavaScriptInvoke(iindex, function, result, params, exception, site);
        }

        public JavaScriptInvoke Invoke(int iindex, int function, int[] params, int exception, CallSiteReference site) {
          return new JavaScriptInvoke(iindex, function, params, exception, site);
        }

        public JavaScriptPropertyRead PropertyRead(int iindex, int result, int objectRef, int memberRef) {
          return new JavaScriptPropertyRead(iindex, result, objectRef, memberRef);
        }

        public JavaScriptPropertyWrite PropertyWrite(int iindex, int objectRef, int memberRef, int value) {
          return new JavaScriptPropertyWrite(iindex, objectRef, memberRef, value);
        }

        public SSAPutInstruction PutInstruction(int iindex, int ref, int value, String field) {
=======
        @Override
        public JavaScriptInvoke Invoke(int function, int result, int[] params, int exception, CallSiteReference site) {
          return new JavaScriptInvoke(function, result, params, exception, site);
        }

        @Override
        public JavaScriptInvoke Invoke(int function, int[] params, int exception, CallSiteReference site) {
          return new JavaScriptInvoke(function, params, exception, site);
        }

        @Override
        public JavaScriptPropertyRead PropertyRead(int result, int objectRef, int memberRef) {
          return new JavaScriptPropertyRead(result, objectRef, memberRef);
        }

        @Override
        public JavaScriptPropertyWrite PropertyWrite(int objectRef, int memberRef, int value) {
          return new JavaScriptPropertyWrite(objectRef, memberRef, value);
        }

        @Override
        public SSAPutInstruction PutInstruction(int ref, int value, String field) {
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
          try {
            byte[] utf8 = field.getBytes("UTF-8");
            return PutInstruction(iindex, ref, value,
Solution content 
          return new JavaScriptInvoke(iindex, function, results, params, exception, site, lexicalReads, lexicalWrites);
        }

        @Override
        public JavaScriptInvoke Invoke(int iindex, int function, int result, int[] params, int exception, CallSiteReference site) {
          return new JavaScriptInvoke(iindex, function, result, params, exception, site);
        }

        @Override
        public JavaScriptInvoke Invoke(int iindex, int function, int[] params, int exception, CallSiteReference site) {
          return new JavaScriptInvoke(iindex, function, params, exception, site);
        }

        @Override
        public JavaScriptPropertyRead PropertyRead(int iindex, int result, int objectRef, int memberRef) {
          return new JavaScriptPropertyRead(iindex, result, objectRef, memberRef);
        }

        @Override
        public JavaScriptPropertyWrite PropertyWrite(int iindex, int objectRef, int memberRef, int value) {
          return new JavaScriptPropertyWrite(iindex, objectRef, memberRef, value);
        }

        @Override
        public SSAPutInstruction PutInstruction(int iindex, int ref, int value, String field) {
          try {
            byte[] utf8 = field.getBytes("UTF-8");
            return PutInstruction(iindex, ref, value,
File
JavaScriptLoader.java
Developer's decision
Combination
Kind of conflict
Annotation
Method declaration
Method signature
Chunk
Conflicting content 
          }
        }

<<<<<<< HEAD
        public JavaScriptTypeOfInstruction TypeOfInstruction(int iindex, int lval, int object) {
          return new JavaScriptTypeOfInstruction(iindex, lval, object);
        }

        public JavaScriptWithRegion WithRegion(int iindex, int expr, boolean isEnter) {
          return new JavaScriptWithRegion(iindex, expr, isEnter);
        }

        public AstAssertInstruction AssertInstruction(int iindex, int value, boolean fromSpecification) {
          return new AstAssertInstruction(iindex, value, fromSpecification);
        }

        public com.ibm.wala.cast.ir.ssa.AssignInstruction AssignInstruction(int iindex, int result, int val) {
          return new AssignInstruction(iindex, result, val);
        }

        public com.ibm.wala.cast.ir.ssa.EachElementGetInstruction EachElementGetInstruction(int iindex, int value, int objectRef) {
          return new EachElementGetInstruction(iindex, value, objectRef);
        }

        public com.ibm.wala.cast.ir.ssa.EachElementHasNextInstruction EachElementHasNextInstruction(int iindex, int value, int objectRef) {
          return new EachElementHasNextInstruction(iindex, value, objectRef);
        }

        public AstEchoInstruction EchoInstruction(int iindex, int[] rvals) {
          return new AstEchoInstruction(iindex, rvals);
        }

        public AstGlobalRead GlobalRead(int iindex, int lhs, FieldReference global) {
          return new AstGlobalRead(iindex, lhs, global);
        }

        public AstGlobalWrite GlobalWrite(int iindex, FieldReference global, int rhs) {
          return new AstGlobalWrite(iindex, global, rhs);
        }

        public AstIsDefinedInstruction IsDefinedInstruction(int iindex, int lval, int rval, int fieldVal, FieldReference fieldRef) {
          return new AstIsDefinedInstruction(iindex, lval, rval, fieldVal, fieldRef);
        }

        public AstIsDefinedInstruction IsDefinedInstruction(int iindex, int lval, int rval, FieldReference fieldRef) {
          return new AstIsDefinedInstruction(iindex, lval, rval, fieldRef);
        }

        public AstIsDefinedInstruction IsDefinedInstruction(int iindex, int lval, int rval, int fieldVal) {
          return new AstIsDefinedInstruction(iindex, lval, rval, fieldVal);
        }

        public AstIsDefinedInstruction IsDefinedInstruction(int iindex, int lval, int rval) {
          return new AstIsDefinedInstruction(iindex, lval, rval);
        }

        public AstLexicalRead LexicalRead(int iindex, Access[] accesses) {
          return new AstLexicalRead(iindex, accesses);
        }

        public AstLexicalRead LexicalRead(int iindex, Access access) {
          return new AstLexicalRead(iindex, access);
        }

        public AstLexicalRead LexicalRead(int iindex, int lhs, String definer, String globalName) {
          return new AstLexicalRead(iindex, lhs, definer, globalName);
        }

        public AstLexicalWrite LexicalWrite(int iindex, Access[] accesses) {
          return new AstLexicalWrite(iindex, accesses);
        }

        public AstLexicalWrite LexicalWrite(int iindex, Access access) {
          return new AstLexicalWrite(iindex, access);
        }

        public AstLexicalWrite LexicalWrite(int iindex, String definer, String globalName, int rhs) {
          return new AstLexicalWrite(iindex, definer, globalName, rhs);
        }

        public SSAArrayLengthInstruction ArrayLengthInstruction(int iindex, int result, int arrayref) {
          throw new UnsupportedOperationException();
        }

        public SSAArrayLoadInstruction ArrayLoadInstruction(int iindex, int result, int arrayref, int index, TypeReference declaredType) {
          throw new UnsupportedOperationException();
        }

        public SSAArrayStoreInstruction ArrayStoreInstruction(int iindex, int arrayref, int index, int value, TypeReference declaredType) {
          throw new UnsupportedOperationException();
        }

        public SSABinaryOpInstruction BinaryOpInstruction(int iindex, IOperator operator, boolean overflow, boolean unsigned, int result,
            int val1, int val2, boolean mayBeInteger) {
          return new SSABinaryOpInstruction(iindex, operator, result, val1, val2, mayBeInteger) {
=======
        @Override
        public JavaScriptTypeOfInstruction TypeOfInstruction(int lval, int object) {
          return new JavaScriptTypeOfInstruction(lval, object);
        }

        @Override
        public JavaScriptWithRegion WithRegion(int expr, boolean isEnter) {
          return new JavaScriptWithRegion(expr, isEnter);
        }

        @Override
        public AstAssertInstruction AssertInstruction(int value, boolean fromSpecification) {
          return new AstAssertInstruction(value, fromSpecification);
        }

        @Override
        public com.ibm.wala.cast.ir.ssa.AssignInstruction AssignInstruction(int result, int val) {
          return new AssignInstruction(result, val);
        }

        @Override
        public com.ibm.wala.cast.ir.ssa.EachElementGetInstruction EachElementGetInstruction(int value, int objectRef) {
          return new EachElementGetInstruction(value, objectRef);
        }

        @Override
        public com.ibm.wala.cast.ir.ssa.EachElementHasNextInstruction EachElementHasNextInstruction(int value, int objectRef) {
          return new EachElementHasNextInstruction(value, objectRef);
        }

        @Override
        public AstEchoInstruction EchoInstruction(int[] rvals) {
          return new AstEchoInstruction(rvals);
        }

        @Override
        public AstGlobalRead GlobalRead(int lhs, FieldReference global) {
          return new AstGlobalRead(lhs, global);
        }

        @Override
        public AstGlobalWrite GlobalWrite(FieldReference global, int rhs) {
          return new AstGlobalWrite(global, rhs);
        }

        @Override
        public AstIsDefinedInstruction IsDefinedInstruction(int lval, int rval, int fieldVal, FieldReference fieldRef) {
          return new AstIsDefinedInstruction(lval, rval, fieldVal, fieldRef);
        }

        @Override
        public AstIsDefinedInstruction IsDefinedInstruction(int lval, int rval, FieldReference fieldRef) {
          return new AstIsDefinedInstruction(lval, rval, fieldRef);
        }

        @Override
        public AstIsDefinedInstruction IsDefinedInstruction(int lval, int rval, int fieldVal) {
          return new AstIsDefinedInstruction(lval, rval, fieldVal);
        }

        @Override
        public AstIsDefinedInstruction IsDefinedInstruction(int lval, int rval) {
          return new AstIsDefinedInstruction(lval, rval);
        }

        @Override
        public AstLexicalRead LexicalRead(Access[] accesses) {
          return new AstLexicalRead(accesses);
        }

        @Override
        public AstLexicalRead LexicalRead(Access access) {
          return new AstLexicalRead(access);
        }

        @Override
        public AstLexicalRead LexicalRead(int lhs, String definer, String globalName) {
          return new AstLexicalRead(lhs, definer, globalName);
        }

        @Override
        public AstLexicalWrite LexicalWrite(Access[] accesses) {
          return new AstLexicalWrite(accesses);
        }

        @Override
        public AstLexicalWrite LexicalWrite(Access access) {
          return new AstLexicalWrite(access);
        }

        @Override
        public AstLexicalWrite LexicalWrite(String definer, String globalName, int rhs) {
          return new AstLexicalWrite(definer, globalName, rhs);
        }

        @Override
        public SSAArrayLengthInstruction ArrayLengthInstruction(int result, int arrayref) {
          throw new UnsupportedOperationException();
        }

        @Override
        public SSAArrayLoadInstruction ArrayLoadInstruction(int result, int arrayref, int index, TypeReference declaredType) {
          throw new UnsupportedOperationException();
        }

        @Override
        public SSAArrayStoreInstruction ArrayStoreInstruction(int arrayref, int index, int value, TypeReference declaredType) {
          throw new UnsupportedOperationException();
        }

        @Override
        public SSABinaryOpInstruction BinaryOpInstruction(IOperator operator, boolean overflow, boolean unsigned, int result,
            int val1, int val2, boolean mayBeInteger) {
          return new SSABinaryOpInstruction(operator, result, val1, val2, mayBeInteger) {
            @Override
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
            public boolean isPEI() {
              return false;
            }
Solution content 
          }
        }

        @Override
        public JavaScriptTypeOfInstruction TypeOfInstruction(int iindex, int lval, int object) {
          return new JavaScriptTypeOfInstruction(iindex, lval, object);
        }

        @Override
        public JavaScriptWithRegion WithRegion(int iindex, int expr, boolean isEnter) {
          return new JavaScriptWithRegion(iindex, expr, isEnter);
        }

        @Override
        public AstAssertInstruction AssertInstruction(int iindex, int value, boolean fromSpecification) {
          return new AstAssertInstruction(iindex, value, fromSpecification);
        }

        @Override
        public com.ibm.wala.cast.ir.ssa.AssignInstruction AssignInstruction(int iindex, int result, int val) {
          return new AssignInstruction(iindex, result, val);
        }

        @Override
        public com.ibm.wala.cast.ir.ssa.EachElementGetInstruction EachElementGetInstruction(int iindex, int value, int objectRef) {
          return new EachElementGetInstruction(iindex, value, objectRef);
        }

        @Override
        public com.ibm.wala.cast.ir.ssa.EachElementHasNextInstruction EachElementHasNextInstruction(int iindex, int value, int objectRef) {
          return new EachElementHasNextInstruction(iindex, value, objectRef);
        }

        @Override
        public AstEchoInstruction EchoInstruction(int iindex, int[] rvals) {
          return new AstEchoInstruction(iindex, rvals);
        }

        @Override
        public AstGlobalRead GlobalRead(int iindex, int lhs, FieldReference global) {
          return new AstGlobalRead(iindex, lhs, global);
        }

        @Override
        public AstGlobalWrite GlobalWrite(int iindex, FieldReference global, int rhs) {
          return new AstGlobalWrite(iindex, global, rhs);
        }

        @Override
        public AstIsDefinedInstruction IsDefinedInstruction(int iindex, int lval, int rval, int fieldVal, FieldReference fieldRef) {
          return new AstIsDefinedInstruction(iindex, lval, rval, fieldVal, fieldRef);
        }

        @Override
        public AstIsDefinedInstruction IsDefinedInstruction(int iindex, int lval, int rval, FieldReference fieldRef) {
          return new AstIsDefinedInstruction(iindex, lval, rval, fieldRef);
        }

        @Override
        public AstIsDefinedInstruction IsDefinedInstruction(int iindex, int lval, int rval, int fieldVal) {
          return new AstIsDefinedInstruction(iindex, lval, rval, fieldVal);
        }

        @Override
        public AstIsDefinedInstruction IsDefinedInstruction(int iindex, int lval, int rval) {
          return new AstIsDefinedInstruction(iindex, lval, rval);
        }

        @Override
        public AstLexicalRead LexicalRead(int iindex, Access[] accesses) {
          return new AstLexicalRead(iindex, accesses);
        }

        @Override
        public AstLexicalRead LexicalRead(int iindex, Access access) {
          return new AstLexicalRead(iindex, access);
        }

        @Override
        public AstLexicalRead LexicalRead(int iindex, int lhs, String definer, String globalName) {
          return new AstLexicalRead(iindex, lhs, definer, globalName);
        }

        @Override
        public AstLexicalWrite LexicalWrite(int iindex, Access[] accesses) {
          return new AstLexicalWrite(iindex, accesses);
        }

        @Override
        public AstLexicalWrite LexicalWrite(int iindex, Access access) {
          return new AstLexicalWrite(iindex, access);
        }

        @Override
        public AstLexicalWrite LexicalWrite(int iindex, String definer, String globalName, int rhs) {
          return new AstLexicalWrite(iindex, definer, globalName, rhs);
        }

        @Override
        public SSAArrayLengthInstruction ArrayLengthInstruction(int iindex, int result, int arrayref) {
          throw new UnsupportedOperationException();
        }

        @Override
        public SSAArrayLoadInstruction ArrayLoadInstruction(int iindex, int result, int arrayref, int index, TypeReference declaredType) {
          throw new UnsupportedOperationException();
        }

        @Override
        public SSAArrayStoreInstruction ArrayStoreInstruction(int iindex, int arrayref, int index, int value, TypeReference declaredType) {
          throw new UnsupportedOperationException();
        }

        @Override
        public SSABinaryOpInstruction BinaryOpInstruction(int iindex, IOperator operator, boolean overflow, boolean unsigned, int result,
            int val1, int val2, boolean mayBeInteger) {
          return new SSABinaryOpInstruction(iindex, operator, result, val1, val2, mayBeInteger) {
            @Override
            public boolean isPEI() {
              return false;
            }
File
JavaScriptLoader.java
Developer's decision
Combination
Kind of conflict
Annotation
Method declaration
Method invocation
Method signature
Return statement
Chunk
Conflicting content 
=======
        @Override
          };
        }

<<<<<<< HEAD
        public SSACheckCastInstruction CheckCastInstruction(int iindex, int result, int val, TypeReference[] types, boolean isPEI) {
          throw new UnsupportedOperationException();
        }

        public SSACheckCastInstruction CheckCastInstruction(int iindex, int result, int val, int[] typeValues, boolean isPEI) {
          throw new UnsupportedOperationException();
        }

        public SSACheckCastInstruction CheckCastInstruction(int iindex, int result, int val, int typeValue, boolean isPEI) {
        public SSACheckCastInstruction CheckCastInstruction(int result, int val, TypeReference[] types, boolean isPEI) {
          throw new UnsupportedOperationException();
        }

        @Override
        public SSACheckCastInstruction CheckCastInstruction(int result, int val, int[] typeValues, boolean isPEI) {
          throw new UnsupportedOperationException();
        }

        @Override
        public SSACheckCastInstruction CheckCastInstruction(int result, int val, int typeValue, boolean isPEI) {
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
          assert isPEI;
          return CheckCastInstruction(iindex, result, val, new int[]{ typeValue }, true);
        }
Solution content 
          };
        }

        @Override
        public SSACheckCastInstruction CheckCastInstruction(int iindex, int result, int val, TypeReference[] types, boolean isPEI) {
          throw new UnsupportedOperationException();
        }

        @Override
        public SSACheckCastInstruction CheckCastInstruction(int iindex, int result, int val, int[] typeValues, boolean isPEI) {
          throw new UnsupportedOperationException();
        }

        @Override
        public SSACheckCastInstruction CheckCastInstruction(int iindex, int result, int val, int typeValue, boolean isPEI) {
          assert isPEI;
          return CheckCastInstruction(iindex, result, val, new int[]{ typeValue }, true);
        }
File
JavaScriptLoader.java
Developer's decision
Combination
Kind of conflict
Annotation
Method declaration
Method signature
Chunk
Conflicting content 
          return CheckCastInstruction(iindex, result, val, new int[]{ typeValue }, true);
        }

<<<<<<< HEAD
        public SSACheckCastInstruction CheckCastInstruction(int iindex, int result, int val, TypeReference type, boolean isPEI) {
=======
        @Override
        public SSACheckCastInstruction CheckCastInstruction(int result, int val, TypeReference type, boolean isPEI) {
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
          assert isPEI;
          return CheckCastInstruction(iindex, result, val, new TypeReference[]{ type }, true);
        }
Solution content 
          return CheckCastInstruction(iindex, result, val, new int[]{ typeValue }, true);
        }

        @Override
        public SSACheckCastInstruction CheckCastInstruction(int iindex, int result, int val, TypeReference type, boolean isPEI) {
          assert isPEI;
          return CheckCastInstruction(iindex, result, val, new TypeReference[]{ type }, true);
        }
File
JavaScriptLoader.java
Developer's decision
Combination
Kind of conflict
Annotation
Method signature
Chunk
Conflicting content 
          return CheckCastInstruction(iindex, result, val, new TypeReference[]{ type }, true);
        }

<<<<<<< HEAD
        public SSAComparisonInstruction ComparisonInstruction(int iindex, Operator operator, int result, int val1, int val2) {
          return new SSAComparisonInstruction(iindex, operator, result, val1, val2);
        }

        public SSAConditionalBranchInstruction ConditionalBranchInstruction(int iindex, 
=======
        @Override
        public SSAComparisonInstruction ComparisonInstruction(Operator operator, int result, int val1, int val2) {
          return new SSAComparisonInstruction(operator, result, val1, val2);
        }

        @Override
        public SSAConditionalBranchInstruction ConditionalBranchInstruction(
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
            com.ibm.wala.shrikeBT.IConditionalBranchInstruction.IOperator operator, TypeReference type, int val1, int val2) {
          return new SSAConditionalBranchInstruction(iindex, operator, type, val1, val2);
        }
Solution content 
          return CheckCastInstruction(iindex, result, val, new TypeReference[]{ type }, true);
        }

        @Override
        public SSAComparisonInstruction ComparisonInstruction(int iindex, Operator operator, int result, int val1, int val2) {
          return new SSAComparisonInstruction(iindex, operator, result, val1, val2);
        }

        @Override
        public SSAConditionalBranchInstruction ConditionalBranchInstruction(int iindex, 
            com.ibm.wala.shrikeBT.IConditionalBranchInstruction.IOperator operator, TypeReference type, int val1, int val2) {
          return new SSAConditionalBranchInstruction(iindex, operator, type, val1, val2);
        }
File
JavaScriptLoader.java
Developer's decision
Combination
Kind of conflict
Annotation
Method declaration
Method signature
Chunk
Conflicting content 
          return new SSAConditionalBranchInstruction(iindex, operator, type, val1, val2);
        }

<<<<<<< HEAD
        public SSAConversionInstruction ConversionInstruction(int iindex, int result, int val, TypeReference fromType, TypeReference toType,
=======
        @Override
        public SSAConversionInstruction ConversionInstruction(int result, int val, TypeReference fromType, TypeReference toType,
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
            boolean overflow) {
          assert !overflow;
          return new SSAConversionInstruction(iindex, result, val, fromType, toType) {
Solution content 
          return new SSAConditionalBranchInstruction(iindex, operator, type, val1, val2);
        }

        @Override
        public SSAConversionInstruction ConversionInstruction(int iindex, int result, int val, TypeReference fromType, TypeReference toType,
            boolean overflow) {
          assert !overflow;
          return new SSAConversionInstruction(iindex, result, val, fromType, toType) {
File
JavaScriptLoader.java
Developer's decision
Combination
Kind of conflict
Annotation
Method signature
Chunk
Conflicting content 
          };
        }

<<<<<<< HEAD
        public SSAGetCaughtExceptionInstruction GetCaughtExceptionInstruction(int iindex, int bbNumber, int exceptionValueNumber) {
          return new SSAGetCaughtExceptionInstruction(iindex, bbNumber, exceptionValueNumber);
        }

        public SSAGetInstruction GetInstruction(int iindex, int result, FieldReference field) {
          throw new UnsupportedOperationException();
        }

        public SSAGetInstruction GetInstruction(int iindex, int result, int ref, FieldReference field) {
          return new SSAGetInstruction(iindex, result, ref, field) {
=======
        @Override
        public SSAGetCaughtExceptionInstruction GetCaughtExceptionInstruction(int bbNumber, int exceptionValueNumber) {
          return new SSAGetCaughtExceptionInstruction(bbNumber, exceptionValueNumber);
        }

        @Override
        public SSAGetInstruction GetInstruction(int result, FieldReference field) {
          throw new UnsupportedOperationException();
        }

        @Override
        public SSAGetInstruction GetInstruction(int result, int ref, FieldReference field) {
          return new SSAGetInstruction(result, ref, field) {
            @Override
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
            public boolean isPEI() {
              return false;
            }
Solution content 
          };
        }

        @Override
        public SSAGetCaughtExceptionInstruction GetCaughtExceptionInstruction(int iindex, int bbNumber, int exceptionValueNumber) {
          return new SSAGetCaughtExceptionInstruction(iindex, bbNumber, exceptionValueNumber);
        }

        @Override
        public SSAGetInstruction GetInstruction(int iindex, int result, FieldReference field) {
          throw new UnsupportedOperationException();
        }

        @Override
        public SSAGetInstruction GetInstruction(int iindex, int result, int ref, FieldReference field) {
          return new SSAGetInstruction(iindex, result, ref, field) {
            @Override
            public boolean isPEI() {
              return false;
            }
File
JavaScriptLoader.java
Developer's decision
Combination
Kind of conflict
Annotation
Method declaration
Method invocation
Method signature
Return statement
Chunk
Conflicting content 
          };
        }

<<<<<<< HEAD
        public SSAGotoInstruction GotoInstruction(int iindex) {
          return new SSAGotoInstruction(iindex);
        }

        public SSAInstanceofInstruction InstanceofInstruction(int iindex, int result, int ref, TypeReference checkedType) {
          throw new UnsupportedOperationException();
        }

        public SSAInvokeInstruction InvokeInstruction(int iindex, int result, int[] params, int exception, CallSiteReference site) {
          throw new UnsupportedOperationException();
        }

        public SSAInvokeInstruction InvokeInstruction(int iindex, int[] params, int exception, CallSiteReference site) {
          throw new UnsupportedOperationException();
        }

        public SSALoadMetadataInstruction LoadMetadataInstruction(int iindex, int lval, TypeReference entityType, Object token) {
          throw new UnsupportedOperationException();
        }

        public SSAMonitorInstruction MonitorInstruction(int iindex, int ref, boolean isEnter) {
          throw new UnsupportedOperationException();
        }

        public SSANewInstruction NewInstruction(int iindex, int result, NewSiteReference site) {
          return new SSANewInstruction(iindex, result, site) {
=======
        @Override
        public SSAGotoInstruction GotoInstruction() {
          return new SSAGotoInstruction();
        }

        @Override
        public SSAInstanceofInstruction InstanceofInstruction(int result, int ref, TypeReference checkedType) {
          throw new UnsupportedOperationException();
        }

        @Override
        public SSAInvokeInstruction InvokeInstruction(int result, int[] params, int exception, CallSiteReference site) {
          throw new UnsupportedOperationException();
        }

        @Override
        public SSAInvokeInstruction InvokeInstruction(int[] params, int exception, CallSiteReference site) {
          throw new UnsupportedOperationException();
        }

        @Override
        public SSALoadMetadataInstruction LoadMetadataInstruction(int lval, TypeReference entityType, Object token) {
          throw new UnsupportedOperationException();
        }

        @Override
        public SSAMonitorInstruction MonitorInstruction(int ref, boolean isEnter) {
          throw new UnsupportedOperationException();
        }

        @Override
        public SSANewInstruction NewInstruction(int result, NewSiteReference site) {
          return new SSANewInstruction(result, site) {
            @Override
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
            public boolean isPEI() {
              return true;
            }
Solution content 
          };
        }
        @Override
        public SSAGotoInstruction GotoInstruction(int iindex) {
          return new SSAGotoInstruction(iindex);
        }

        @Override
        public SSAInstanceofInstruction InstanceofInstruction(int iindex, int result, int ref, TypeReference checkedType) {
          throw new UnsupportedOperationException();
        }

        @Override
        public SSAInvokeInstruction InvokeInstruction(int iindex, int result, int[] params, int exception, CallSiteReference site) {
          throw new UnsupportedOperationException();
        }

        @Override
        public SSAInvokeInstruction InvokeInstruction(int iindex, int[] params, int exception, CallSiteReference site) {
          throw new UnsupportedOperationException();
        }

        @Override
        public SSALoadMetadataInstruction LoadMetadataInstruction(int iindex, int lval, TypeReference entityType, Object token) {
          throw new UnsupportedOperationException();
        }

        @Override
        public SSAMonitorInstruction MonitorInstruction(int iindex, int ref, boolean isEnter) {
          throw new UnsupportedOperationException();
        }

        @Override
        public SSANewInstruction NewInstruction(int iindex, int result, NewSiteReference site) {
          return new SSANewInstruction(iindex, result, site) {
            @Override
            public boolean isPEI() {
              return true;
            }
File
JavaScriptLoader.java
Developer's decision
Combination
Kind of conflict
Annotation
Method declaration
Method invocation
Method signature
Return statement
Chunk
Conflicting content 
          };
        }

<<<<<<< HEAD
        public SSANewInstruction NewInstruction(int iindex, int result, NewSiteReference site, int[] params) {
          throw new UnsupportedOperationException();
        }

        public SSAPhiInstruction PhiInstruction(int iindex, int result, int[] params) {
          return new SSAPhiInstruction(iindex, result, params);
        }

        public SSAPiInstruction PiInstruction(int iindex, int result, int val, int piBlock, int successorBlock, SSAInstruction cause) {
          return new SSAPiInstruction(iindex, result, val, piBlock, successorBlock, cause);
        }

        public SSAPutInstruction PutInstruction(int iindex, int ref, int value, FieldReference field) {
          return new SSAPutInstruction(iindex, ref, value, field) {
=======
        @Override
        public SSANewInstruction NewInstruction(int result, NewSiteReference site, int[] params) {
          throw new UnsupportedOperationException();
        }

        @Override
        public SSAPhiInstruction PhiInstruction(int result, int[] params) {
          return new SSAPhiInstruction(result, params);
        }

        @Override
        public SSAPiInstruction PiInstruction(int result, int val, int piBlock, int successorBlock, SSAInstruction cause) {
          return new SSAPiInstruction(result, val, piBlock, successorBlock, cause);
        }

        @Override
        public SSAPutInstruction PutInstruction(int ref, int value, FieldReference field) {
          return new SSAPutInstruction(ref, value, field) {
            @Override
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
            public boolean isPEI() {
              return false;
            }
Solution content 
          };
        }

        @Override
        public SSANewInstruction NewInstruction(int iindex, int result, NewSiteReference site, int[] params) {
          throw new UnsupportedOperationException();
        }

        @Override
        public SSAPhiInstruction PhiInstruction(int iindex, int result, int[] params) {
          return new SSAPhiInstruction(iindex, result, params);
        }

        @Override
        public SSAPiInstruction PiInstruction(int iindex, int result, int val, int piBlock, int successorBlock, SSAInstruction cause) {
          return new SSAPiInstruction(iindex, result, val, piBlock, successorBlock, cause);
        }

        @Override
        public SSAPutInstruction PutInstruction(int iindex, int ref, int value, FieldReference field) {
          return new SSAPutInstruction(iindex, ref, value, field) {
            @Override
            public boolean isPEI() {
              return false;
            }
File
JavaScriptLoader.java
Developer's decision
Combination
Kind of conflict
Annotation
Method declaration
Method invocation
Method signature
Return statement
Chunk
Conflicting content 
          };
        }

<<<<<<< HEAD
        public SSAPutInstruction PutInstruction(int iindex, int value, FieldReference field) {
          throw new UnsupportedOperationException();
        }

        public SSAReturnInstruction ReturnInstruction(int iindex) {
          return new SSAReturnInstruction(iindex);
        }

        public SSAReturnInstruction ReturnInstruction(int iindex, int result, boolean isPrimitive) {
          return new SSAReturnInstruction(iindex, result, isPrimitive);
        }

        public SSASwitchInstruction SwitchInstruction(int iindex, int val, int defaultLabel, int[] casesAndLabels) {
          return new SSASwitchInstruction(iindex, val, defaultLabel, casesAndLabels);
        }

        public SSAThrowInstruction ThrowInstruction(int iindex, int exception) {
          return new SSAThrowInstruction(iindex, exception) {
=======
        @Override
        public SSAPutInstruction PutInstruction(int value, FieldReference field) {
          throw new UnsupportedOperationException();
        }

        @Override
        public SSAReturnInstruction ReturnInstruction() {
          return new SSAReturnInstruction();
        }

        @Override
        public SSAReturnInstruction ReturnInstruction(int result, boolean isPrimitive) {
          return new SSAReturnInstruction(result, isPrimitive);
        }

        @Override
        public SSASwitchInstruction SwitchInstruction(int val, int defaultLabel, int[] casesAndLabels) {
          return new SSASwitchInstruction(val, defaultLabel, casesAndLabels);
        }

        @Override
        public SSAThrowInstruction ThrowInstruction(int exception) {
          return new SSAThrowInstruction(exception) {
            @Override
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
            public boolean isPEI() {
              return true;
            }
Solution content 
          };
        }

        @Override
        public SSAPutInstruction PutInstruction(int iindex, int value, FieldReference field) {
          throw new UnsupportedOperationException();
        }

        @Override
        public SSAReturnInstruction ReturnInstruction(int iindex) {
          return new SSAReturnInstruction(iindex);
        }

        @Override
        public SSAReturnInstruction ReturnInstruction(int iindex, int result, boolean isPrimitive) {
          return new SSAReturnInstruction(iindex, result, isPrimitive);
        }

        @Override
        public SSASwitchInstruction SwitchInstruction(int iindex, int val, int defaultLabel, int[] casesAndLabels) {
          return new SSASwitchInstruction(iindex, val, defaultLabel, casesAndLabels);
        }

        @Override
        public SSAThrowInstruction ThrowInstruction(int iindex, int exception) {
          return new SSAThrowInstruction(iindex, exception) {
            @Override
            public boolean isPEI() {
              return true;
            }
File
JavaScriptLoader.java
Developer's decision
Combination
Kind of conflict
Annotation
Method declaration
Method invocation
Method signature
Return statement
Chunk
Conflicting content 
          };
        }

<<<<<<< HEAD
        public SSAUnaryOpInstruction UnaryOpInstruction(int iindex, com.ibm.wala.shrikeBT.IUnaryOpInstruction.IOperator operator, int result,
=======
        @Override
        public SSAUnaryOpInstruction UnaryOpInstruction(com.ibm.wala.shrikeBT.IUnaryOpInstruction.IOperator operator, int result,
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
            int val) {
          return new SSAUnaryOpInstruction(iindex, operator, result, val);
        }
Solution content 
          };
        }

        @Override
        public SSAUnaryOpInstruction UnaryOpInstruction(int iindex, com.ibm.wala.shrikeBT.IUnaryOpInstruction.IOperator operator, int result,
            int val) {
          return new SSAUnaryOpInstruction(iindex, operator, result, val);
        }
File
JavaScriptLoader.java
Developer's decision
Combination
Kind of conflict
Annotation
Method signature
Chunk
Conflicting content 
          return new SSAUnaryOpInstruction(iindex, operator, result, val);
        }

<<<<<<< HEAD
        public SSAAddressOfInstruction AddressOfInstruction(int iindex, int lval, int local, TypeReference pointeeType) {
          throw new UnsupportedOperationException();
        }

        public SSAAddressOfInstruction AddressOfInstruction(int iindex, int lval, int local, int indexVal, TypeReference pointeeType) {
          throw new UnsupportedOperationException();
        }

        public SSAAddressOfInstruction AddressOfInstruction(int iindex, int lval, int local, FieldReference field, TypeReference pointeeType) {
          throw new UnsupportedOperationException();
        }

        public SSALoadIndirectInstruction LoadIndirectInstruction(int iindex, int lval, TypeReference t, int addressVal) {
          throw new UnsupportedOperationException();
        }

        public SSAStoreIndirectInstruction StoreIndirectInstruction(int iindex, int addressVal, int rval, TypeReference t) {
=======
        @Override
        public SSAAddressOfInstruction AddressOfInstruction(int lval, int local, TypeReference pointeeType) {
          throw new UnsupportedOperationException();
        }

        @Override
        public SSAAddressOfInstruction AddressOfInstruction(int lval, int local, int indexVal, TypeReference pointeeType) {
          throw new UnsupportedOperationException();
        }

        @Override
        public SSAAddressOfInstruction AddressOfInstruction(int lval, int local, FieldReference field, TypeReference pointeeType) {
          throw new UnsupportedOperationException();
        }

        @Override
        public SSALoadIndirectInstruction LoadIndirectInstruction(int lval, TypeReference t, int addressVal) {
          throw new UnsupportedOperationException();
        }

        @Override
        public SSAStoreIndirectInstruction StoreIndirectInstruction(int addressVal, int rval, TypeReference t) {
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
          throw new UnsupportedOperationException();
        }
Solution content 
          return new SSAUnaryOpInstruction(iindex, operator, result, val);
        }

        @Override
        public SSAAddressOfInstruction AddressOfInstruction(int iindex, int lval, int local, TypeReference pointeeType) {
          throw new UnsupportedOperationException();
        }

        @Override
        public SSAAddressOfInstruction AddressOfInstruction(int iindex, int lval, int local, int indexVal, TypeReference pointeeType) {
          throw new UnsupportedOperationException();
        }

        @Override
        public SSAAddressOfInstruction AddressOfInstruction(int iindex, int lval, int local, FieldReference field, TypeReference pointeeType) {
          throw new UnsupportedOperationException();
        }

        @Override
        public SSALoadIndirectInstruction LoadIndirectInstruction(int iindex, int lval, TypeReference t, int addressVal) {
          throw new UnsupportedOperationException();
        }

        @Override
        public SSAStoreIndirectInstruction StoreIndirectInstruction(int iindex, int addressVal, int rval, TypeReference t) {
          throw new UnsupportedOperationException();
        }
File
JavaScriptLoader.java
Developer's decision
Combination
Kind of conflict
Annotation
Method declaration
Method signature
Chunk
Conflicting content 
 *****************************************************************************/
package com.ibm.wala.cast.js.translator;

<<<<<<< HEAD
=======
import java.util.Map;

>>>>>>> b984760100e3be325d458f61b0d556f479701c95
import com.ibm.wala.cast.ir.translator.AstTranslator;
import com.ibm.wala.cast.js.loader.JSCallSiteReference;
import com.ibm.wala.cast.js.loader.JavaScriptLoader;
Solution content 
 *****************************************************************************/
package com.ibm.wala.cast.js.translator;

import java.util.Map;

import com.ibm.wala.cast.ir.translator.AstTranslator;
import com.ibm.wala.cast.js.loader.JSCallSiteReference;
import com.ibm.wala.cast.js.loader.JavaScriptLoader;
File
JSAstTranslator.java
Developer's decision
Version 2
Kind of conflict
Import
Chunk
Conflicting content 
    if (elt.getKind() == CAstNode.CONSTANT && elt.getValue() instanceof String) {
      String field = (String) elt.getValue();
      if (isPrologueScript(context) && "__proto__".equals(field)) {
<<<<<<< HEAD
        context.cfg().addInstruction(((JSInstructionFactory) insts).SetPrototype(context.cfg().getCurrentInstruction(), receiver, rval));
=======
        context.cfg().addInstruction(((JSInstructionFactory) insts).SetPrototype(receiver, rval));
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
        return;
      }
    }
Solution content 
    if (elt.getKind() == CAstNode.CONSTANT && elt.getValue() instanceof String) {
      String field = (String) elt.getValue();
      if (isPrologueScript(context) && "__proto__".equals(field)) {
        context.cfg().addInstruction(((JSInstructionFactory) insts).SetPrototype(context.cfg().getCurrentInstruction(), receiver, rval));
        return;
      }
    }
File
JSAstTranslator.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
      }
    } else {
    */
<<<<<<< HEAD
      context.cfg().addInstruction(((JSInstructionFactory) insts).PropertyWrite(context.cfg().getCurrentInstruction(), receiver, context.getValue(elt), rval));
=======
      context.cfg().addInstruction(((JSInstructionFactory) insts).PropertyWrite(receiver, context.getValue(elt), rval));
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
   // }
  }
Solution content 
      }
    } else {
    */
      context.cfg().addInstruction(((JSInstructionFactory) insts).PropertyWrite(context.cfg().getCurrentInstruction(), receiver, context.getValue(elt), rval));
   // }
  }
File
JSAstTranslator.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
    return base.getPointerKeyForArrayContents(I);
  }

<<<<<<< HEAD
=======
  @Override
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
  public Iterator getPointerKeysForReflectedFieldWrite(InstanceKey I, InstanceKey F) {
    List result = new LinkedList();
Solution content 
    return base.getPointerKeyForArrayContents(I);
  }

  @Override
  public Iterator getPointerKeysForReflectedFieldWrite(InstanceKey I, InstanceKey F) {
    List result = new LinkedList();
File
DelegatingAstPointerKeys.java
Developer's decision
Version 2
Kind of conflict
Annotation
Chunk
Conflicting content 
    return null;
  }
  
<<<<<<< HEAD
=======
  @Override
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
  public Iterator getPointerKeysForReflectedFieldRead(InstanceKey I, InstanceKey F) {
    if (F instanceof ConstantKey) {
      PointerKey ifk = getInstanceFieldPointerKeyForConstant(I, (ConstantKey) F);
Solution content 
    return null;
  }
  
  @Override
  public Iterator getPointerKeysForReflectedFieldRead(InstanceKey I, InstanceKey F) {
    if (F instanceof ConstantKey) {
      PointerKey ifk = getInstanceFieldPointerKeyForConstant(I, (ConstantKey) F);
File
DelegatingAstPointerKeys.java
Developer's decision
Version 2
Kind of conflict
Annotation
Chunk
Conflicting content 
import com.ibm.wala.classLoader.ProgramCounter;
import com.ibm.wala.ipa.callgraph.CGNode;
import com.ibm.wala.ipa.callgraph.CallGraph;
<<<<<<< HEAD
import com.ibm.wala.ipa.callgraph.ContextItem;
=======
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
import com.ibm.wala.ipa.callgraph.propagation.InstanceKey;
import com.ibm.wala.ipa.callgraph.propagation.InstanceKeyFactory;
import com.ibm.wala.ipa.callgraph.propagation.PointerKey;
Solution content 
import com.ibm.wala.classLoader.ProgramCounter;
import com.ibm.wala.ipa.callgraph.CGNode;
import com.ibm.wala.ipa.callgraph.CallGraph;
import com.ibm.wala.ipa.callgraph.propagation.InstanceKey;
import com.ibm.wala.ipa.callgraph.propagation.InstanceKeyFactory;
import com.ibm.wala.ipa.callgraph.propagation.PointerKey;
File
ScopeMappingInstanceKeys.java
Developer's decision
Version 2
Kind of conflict
Import
Chunk
Conflicting content 
     * @return
     */
    public Iterator getFunargNodes(Pair name) {
<<<<<<< HEAD
      if (AstTranslator.NEW_LEXICAL) {
        Collection constructorCallers = getConstructorCallers(this, name);
        assert constructorCallers != null && !constructorCallers.isEmpty() : "no callers for constructor";
        Iterator result = EmptyIterator.instance();
        for (CGNode callerOfConstructor : constructorCallers) {
          if (callerOfConstructor.getMethod().getReference().getDeclaringClass().getName().toString().equals(name.snd)){
            result = new CompoundIterator(result, new NonNullSingletonIterator(callerOfConstructor));
          } else {
            PointerKey funcKey = builder.getPointerKeyForLocal(callerOfConstructor, 1);
            OrdinalSet funcPtrs = builder.getPointerAnalysis().getPointsToSet(funcKey);
            for (InstanceKey funcPtr : funcPtrs) {
              if (funcPtr instanceof ScopeMappingInstanceKey) {
                result = new CompoundIterator(result, ((ScopeMappingInstanceKey) funcPtr).getFunargNodes(name));                
              }              
=======
      Collection constructorCallers = getConstructorCallers(this, name);
      assert constructorCallers != null && !constructorCallers.isEmpty() : "no callers for constructor";
      Iterator result = EmptyIterator.instance();
      for (CGNode callerOfConstructor : constructorCallers) {
        if (callerOfConstructor.getMethod().getReference().getDeclaringClass().getName().toString().equals(name.snd)) {
          result = new CompoundIterator(result, new NonNullSingletonIterator(callerOfConstructor));
        } else {
          PointerKey funcKey = builder.getPointerKeyForLocal(callerOfConstructor, 1);
          OrdinalSet funcPtrs = builder.getPointerAnalysis().getPointsToSet(funcKey);
          for (InstanceKey funcPtr : funcPtrs) {
            if (funcPtr instanceof ScopeMappingInstanceKey) {
              result = new CompoundIterator(result, ((ScopeMappingInstanceKey) funcPtr).getFunargNodes(name));
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
            }
          }
        }
Solution content 
     * @return
     */
    public Iterator getFunargNodes(Pair name) {
      Collection constructorCallers = getConstructorCallers(this, name);
      assert constructorCallers != null && !constructorCallers.isEmpty() : "no callers for constructor";
      Iterator result = EmptyIterator.instance();
      for (CGNode callerOfConstructor : constructorCallers) {
        if (callerOfConstructor.getMethod().getReference().getDeclaringClass().getName().toString().equals(name.snd)) {
          result = new CompoundIterator(result, new NonNullSingletonIterator(callerOfConstructor));
        } else {
          PointerKey funcKey = builder.getPointerKeyForLocal(callerOfConstructor, 1);
          OrdinalSet funcPtrs = builder.getPointerAnalysis().getPointsToSet(funcKey);
          for (InstanceKey funcPtr : funcPtrs) {
            if (funcPtr instanceof ScopeMappingInstanceKey) {
              result = new CompoundIterator(result, ((ScopeMappingInstanceKey) funcPtr).getFunargNodes(name));
            }
          }
        }
File
ScopeMappingInstanceKeys.java
Developer's decision
Version 2
Kind of conflict
Assert statement
For statement
If statement
Method invocation
Variable
Chunk
Conflicting content 
    @Override

<<<<<<< HEAD
=======
      return creator;
    }
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
    public Iterator> getCreationSites(CallGraph CG) {
      return new FilterIterator>(
          base.getCreationSites(CG),
Solution content 
      return creator;
    }

    @Override
    public Iterator> getCreationSites(CallGraph CG) {
      return new FilterIterator>(
          base.getCreationSites(CG),
File
ScopeMappingInstanceKeys.java
Developer's decision
Version 2
Kind of conflict
Annotation
Chunk
Conflicting content 
      return new FilterIterator>(
          base.getCreationSites(CG),
          new Filter>() {
<<<<<<< HEAD
=======
            @Override
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
            public boolean accepts(Pair o) {
              return o.fst.equals(creator);
            }
Solution content 
      return new FilterIterator>(
          base.getCreationSites(CG),
          new Filter>() {
            @Override
            public boolean accepts(Pair o) {
              return o.fst.equals(creator);
            }
File
ScopeMappingInstanceKeys.java
Developer's decision
Version 2
Kind of conflict
Annotation
Chunk
Conflicting content 
  }

  
<<<<<<< HEAD
=======
  @Override
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
  public Collection getAnnotations() {
    return null;
  }
Solution content 
  }

  
  @Override
  public Collection getAnnotations() {
    return null;
  }
File
AbstractEntity.java
Developer's decision
Version 2
Kind of conflict
Annotation
Chunk
Conflicting content 
   * generate prologue code for each function body
   */
  protected void doPrologue(WalkContext context) {
<<<<<<< HEAD
    // if we are SSA converting lexical accesses, add a placeholder instruction
    // eventually (via mutation of its Access array) reads all relevant lexical
    // variables at the beginning of the method.
    if (useLocalValuesForLexicalVars()) {
      context.cfg().addInstruction(new AstLexicalRead(context.cfg().currentInstruction, new Access[0]));
    } else {
      // perform a lexical write to copy the value stored in the local
      // associated with each parameter to the lexical name
      final CAstEntity entity = context.top();
      Set exposedNames = entity2ExposedNames.get(entity);
      if (exposedNames != null) {
        for (String arg : entity.getArgumentNames()) {
          if (exposedNames.contains(arg)) {
            final Scope currentScope = context.currentScope();
            Symbol symbol = currentScope.lookup(arg);
            assert symbol.getDefiningScope() == currentScope;
            int argVN = symbol.valueNumber();
            Access A = new Access(arg, context.getEntityName(entity), argVN);
            context.cfg().addInstruction(new AstLexicalWrite(context.cfg().currentInstruction, A));
          }
=======
    // perform a lexical write to copy the value stored in the local
    // associated with each parameter to the lexical name
    final CAstEntity entity = context.top();
    Set exposedNames = entity2ExposedNames.get(entity);
    if (exposedNames != null) {
      for (String arg : entity.getArgumentNames()) {
        if (exposedNames.contains(arg)) {
          final Scope currentScope = context.currentScope();
          Symbol symbol = currentScope.lookup(arg);
          assert symbol.getDefiningScope() == currentScope;
          int argVN = symbol.valueNumber();
          Access A = new Access(arg, context.getEntityName(entity), argVN);
          context.cfg().addInstruction(new AstLexicalWrite(A));
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
        }
      }
    }
Solution content 
   * generate prologue code for each function body
   */
  protected void doPrologue(WalkContext context) {
    // perform a lexical write to copy the value stored in the local
    // associated with each parameter to the lexical name
    final CAstEntity entity = context.top();
    Set exposedNames = entity2ExposedNames.get(entity);
    if (exposedNames != null) {
      for (String arg : entity.getArgumentNames()) {
        if (exposedNames.contains(arg)) {
          final Scope currentScope = context.currentScope();
          Symbol symbol = currentScope.lookup(arg);
          assert symbol.getDefiningScope() == currentScope;
          int argVN = symbol.valueNumber();
          Access A = new Access(arg, context.getEntityName(entity), argVN);
          context.cfg().addInstruction(new AstLexicalWrite(context.cfg().currentInstruction, A));
        }
      }
    }
File
AstTranslator.java
Developer's decision
Combination
Kind of conflict
Assert statement
Comment
For statement
If statement
Method invocation
Variable
Chunk
Conflicting content 
    // record in declaring scope that the name is exposed to a nested scope
    addExposedName(E, E, name, definingScope.lookup(name).valueNumber(), false, context);
    final String entityName = context.getEntityName(E);
<<<<<<< HEAD
    if (useLocalValuesForLexicalVars()) {
      // lexically-scoped variables can be given a single vn in a method
//<<<<<<< .mine
//      Access A = new Access(name, context.getEntityName(E), vn);
//=======
//>>>>>>> .r4421

//<<<<<<< .mine
      // (context.top() is current entity)
      // record the name as exposed for the current entity, since if the name is
      // updated via a call to a nested function, SSA for the current entity may
      // need to be updated with the new definition
//      addExposedName(context.top(), E, name, vn, false, context);
//=======
      markExposedInEnclosingEntities(context, name, definingScope, E, entityName, false);
//>>>>>>> .r4421

//<<<<<<< .mine
      // record the access; later, the Accesses in the instruction
      int result = context.currentScope().allocateTempValue();
      // defining vn will be adjusted based on this information; see
      // patchLexicalAccesses()
//      addAccess(context, context.top(), A);
//=======
      return S.valueNumber();
//>>>>>>> .r4421

    } else {
      // lexically-scoped variables should be read from their scope each time
//<<<<<<< .mine
//      Access A = new Access(name, context.getEntityName(E), result);
//=======
      Access A = new Access(name, entityName, result);
      context.cfg().addInstruction(new AstLexicalRead(context.cfg().currentInstruction, A));
      markExposedInEnclosingEntities(context, name, definingScope, E, entityName, false);
      return result;
    }
=======
    int result = context.currentScope().allocateTempValue();
    Access A = new Access(name, entityName, result);
    context.cfg().addInstruction(new AstLexicalRead(A));
    markExposedInEnclosingEntities(context, name, definingScope, E, entityName, false);
    return result;
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
  }

  /**
Solution content 
  }
    return result;
    // record in declaring scope that the name is exposed to a nested scope
    addExposedName(E, E, name, definingScope.lookup(name).valueNumber(), false, context);
    final String entityName = context.getEntityName(E);
    int result = context.currentScope().allocateTempValue();
    Access A = new Access(name, entityName, result);
    context.cfg().addInstruction(new AstLexicalRead(context.cfg().currentInstruction, A));
    markExposedInEnclosingEntities(context, name, definingScope, E, entityName, false);

  /**
File
AstTranslator.java
Developer's decision
Combination
Kind of conflict
If statement
Method invocation
Return statement
Variable
Chunk
Conflicting content 
    // record in declaring scope that the name is exposed to a nested scope
    addExposedName(E, E, name, definingScope.lookup(name).valueNumber(), true, context);

<<<<<<< HEAD
    if (useLocalValuesForLexicalVars()) {
      // lexically-scoped variables can be given a single vn in a method
      
      markExposedInEnclosingEntities(context, name, definingScope, E, context.getEntityName(E), true);

      context.cfg().addInstruction(new AssignInstruction(context.cfg().currentInstruction, S.valueNumber(), rval));
      // we add write instructions at every access for now
      // eventually, we may restructure the method to do a single combined write
      // before exit
      Access A = new Access(name, context.getEntityName(E), rval);
      context.cfg().addInstruction(new AstLexicalWrite(context.cfg().currentInstruction, A));

    } else {
      // lexically-scoped variables must be written in their scope each time
      Access A = new Access(name, context.getEntityName(E), rval);
      context.cfg().addInstruction(new AstLexicalWrite(context.cfg().currentInstruction, A));
      markExposedInEnclosingEntities(context, name, definingScope, E, context.getEntityName(E), true);
    }
=======
    // lexically-scoped variables must be written in their scope each time
    Access A = new Access(name, context.getEntityName(E), rval);
    context.cfg().addInstruction(new AstLexicalWrite(A));
    markExposedInEnclosingEntities(context, name, definingScope, E, context.getEntityName(E), true);
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
  }

  /**
Solution content 
    // record in declaring scope that the name is exposed to a nested scope
    addExposedName(E, E, name, definingScope.lookup(name).valueNumber(), true, context);

    // lexically-scoped variables must be written in their scope each time
    Access A = new Access(name, context.getEntityName(E), rval);
    context.cfg().addInstruction(new AstLexicalWrite(context.cfg().currentInstruction, A));
    markExposedInEnclosingEntities(context, name, definingScope, E, context.getEntityName(E), true);
  }

  /**
File
AstTranslator.java
Developer's decision
Combination
Kind of conflict
Comment
If statement
Method invocation
Variable
Chunk
Conflicting content 
    } else {
    // Global variables can be treated as lexicals defined in the CG root, or
    if (treatGlobalsAsLexicallyScoped()) {

<<<<<<< HEAD
      // lexically-scoped variables can be given a single vn in a method, or
      if (useLocalValuesForLexicalVars()) {
        int vn = S.valueNumber();
        Access A = new Access(name, null, vn);

        addExposedName(context.top(), null, name, vn, false, context);
        addAccess(context, context.top(), A);

        return vn;

        // lexically-scoped variables can be read from their scope each time
      } else {
        int result = context.currentScope().allocateTempValue();
        Access A = new Access(name, null, result);
        context.cfg().addInstruction(new AstLexicalRead(context.cfg().currentInstruction, A));
        addAccess(context, context.top(), A);
        return result;
      }
=======
      int result = context.currentScope().allocateTempValue();
      Access A = new Access(name, null, result);
      context.cfg().addInstruction(new AstLexicalRead(A));
      addAccess(context, context.top(), A);
      return result;
>>>>>>> b984760100e3be325d458f61b0d556f479701c95

      // globals can be treated as a single static location
Solution content 
    // Global variables can be treated as lexicals defined in the CG root, or
    if (treatGlobalsAsLexicallyScoped()) {

      int result = context.currentScope().allocateTempValue();
      Access A = new Access(name, null, result);
      context.cfg().addInstruction(new AstLexicalRead(context.cfg().currentInstruction, A));
      addAccess(context, context.top(), A);
      return result;

      // globals can be treated as a single static location
    } else {
File
AstTranslator.java
Developer's decision
Combination
Kind of conflict
Comment
If statement
Method invocation
Return statement
Variable
Chunk
Conflicting content 
    // Global variables can be treated as lexicals defined in the CG root, or
    if (treatGlobalsAsLexicallyScoped()) {

<<<<<<< HEAD
      // lexically-scoped variables can be given a single vn in a method, or
      if (useLocalValuesForLexicalVars()) {
        int vn = S.valueNumber();
        Access A = new Access(name, null, vn);

        addExposedName(context.top(), null, name, vn, true, context);
        addAccess(context, context.top(), A);

        context.cfg().addInstruction(new AssignInstruction(context.cfg().currentInstruction, vn, rval));
        context.cfg().addInstruction(new AstLexicalWrite(context.cfg().currentInstruction, A));

        // lexically-scoped variables can be read from their scope each time
      } else {
        Access A = new Access(name, null, rval);
        context.cfg().addInstruction(new AstLexicalWrite(context.cfg().currentInstruction, A));
        addAccess(context, context.top(), A);
      }
=======
      Access A = new Access(name, null, rval);
      context.cfg().addInstruction(new AstLexicalWrite(A));
      addAccess(context, context.top(), A);
>>>>>>> b984760100e3be325d458f61b0d556f479701c95

      // globals can be treated as a single static location
    } else {
Solution content 
    // Global variables can be treated as lexicals defined in the CG root, or
    if (treatGlobalsAsLexicallyScoped()) {

      Access A = new Access(name, null, rval);
      context.cfg().addInstruction(new AstLexicalWrite(context.cfg().currentInstruction, A));
      addAccess(context, context.top(), A);

      // globals can be treated as a single static location
    } else {
File
AstTranslator.java
Developer's decision
Combination
Kind of conflict
Comment
If statement
Method invocation
Variable
Chunk
Conflicting content 
          if (exception) {
            setCurrentBlockAsHandler();
            e = sourceContext.astContext.currentScope().allocateTempValue();
<<<<<<< HEAD
            addInstruction(insts.GetCaughtExceptionInstruction(currentInstruction, startBlock.getNumber(), e));
            sourceContext.astContext.setCatchType(startBlock.getNumber(), defaultCatchType());
=======
            addInstruction(insts.GetCaughtExceptionInstruction(startBlock.getNumber(), e));
            sourceContext.astContext.setCatchType(startBlock, defaultCatchType());
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
          }

          while (sourceContext != null && (targetContext == null || !targetContext.covers(sourceContext))) {
Solution content 
          if (exception) {
            setCurrentBlockAsHandler();
            e = sourceContext.astContext.currentScope().allocateTempValue();
            addInstruction(insts.GetCaughtExceptionInstruction(currentInstruction, startBlock.getNumber(), e));
            sourceContext.astContext.setCatchType(startBlock, defaultCatchType());
          }

          while (sourceContext != null && (targetContext == null || !targetContext.covers(sourceContext))) {
File
AstTranslator.java
Developer's decision
Combination
Kind of conflict
Method invocation
Chunk
Conflicting content 
          return AstDynamicPropertyClass.this.getClassHierarchy();
        }
        
<<<<<<< HEAD
=======
        @Override
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
        public Collection getAnnotations() {
          return Collections.emptySet();
        }
Solution content 
          return AstDynamicPropertyClass.this.getClassHierarchy();
        }
        
        @Override
        public Collection getAnnotations() {
          return Collections.emptySet();
        }
File
AstDynamicPropertyClass.java
Developer's decision
Version 2
Kind of conflict
Annotation
Chunk
Conflicting content 
    this.ref = ref;
    this.cha = cha;
    this.annotations = annotations;
<<<<<<< HEAD
  }

  
  public Collection getAnnotations() {
    return annotations;
=======
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
  }
Solution content 
    this.ref = ref;
    this.cha = cha;
    this.annotations = annotations;
  }
File
AstField.java
Developer's decision
Version 2
Kind of conflict
Attribute
Method signature
Return statement
Chunk
Conflicting content 
  private final Collection annotations;

  protected AstMethod(IClass cls, Collection qualifiers, AbstractCFG cfg, SymbolTable symtab, MethodReference ref,
<<<<<<< HEAD
      boolean hasCatchBlock, TypeReference[][] catchTypes, boolean hasMonitorOp, AstLexicalInformation lexicalInfo,
=======
      boolean hasCatchBlock, Map caughtTypes, boolean hasMonitorOp, AstLexicalInformation lexicalInfo,
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
      DebuggingInformation debugInfo, Collection annotations) {
    this.cls = cls;
    this.cfg = cfg;
Solution content 
  private final Collection annotations;

  protected AstMethod(IClass cls, Collection qualifiers, AbstractCFG cfg, SymbolTable symtab, MethodReference ref,
      boolean hasCatchBlock, Map caughtTypes, boolean hasMonitorOp, AstLexicalInformation lexicalInfo,
      DebuggingInformation debugInfo, Collection annotations) {
    this.cls = cls;
    this.cfg = cfg;
File
AstMethod.java
Developer's decision
Version 2
Kind of conflict
Variable
Chunk
Conflicting content 
    return debugInfo;
  }

<<<<<<< HEAD
=======
  @Override
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
  public Collection getAnnotations() {
    return annotations;
  }
Solution content 
    return debugInfo;
  }

  @Override
  public Collection getAnnotations() {
    return annotations;
  }
File
AstMethod.java
Developer's decision
Version 2
Kind of conflict
Annotation
Chunk
Conflicting content 
   * The CAst type of this entity.
   */
  CAstType getType();
<<<<<<< HEAD
  
=======

>>>>>>> b984760100e3be325d458f61b0d556f479701c95
  /**
   * Returns the set of any annotations this entity may have
   */
Solution content 
   * The CAst type of this entity.
   */
  CAstType getType();

  /**
   * Returns the set of any annotations this entity may have
   */
File
CAstEntity.java
Developer's decision
Version 1
Kind of conflict
Blank
Chunk
Conflicting content 
	return base.getType();
    }

<<<<<<< HEAD
=======
    @Override
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
    public Collection getAnnotations() {
      return base.getAnnotations();
    }
Solution content 
	return base.getType();
    }

    @Override
    public Collection getAnnotations() {
      return base.getAnnotations();
    }
File
DelegatingEntity.java
Developer's decision
Version 2
Kind of conflict
Annotation
Chunk
Conflicting content 
  private static final boolean DEBUG = false;

<<<<<<< HEAD
/** BEGIN Custom change: caching */
  private final Map cache = HashMapFactory.make();
  
/** END Custom change: caching */
=======
  @Override
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
  public IR getIR(CGNode node) {
    if (node == null) {
      throw new IllegalArgumentException("node is null");
Solution content 
  private static final boolean DEBUG = false;

/** BEGIN Custom change: caching */
  private final Map cache = HashMapFactory.make();
  
/** END Custom change: caching */
  @Override
  public IR getIR(CGNode node) {
    if (node == null) {
      throw new IllegalArgumentException("node is null");
File
ClassFactoryContextInterpreter.java
Developer's decision
Concatenation
Kind of conflict
Annotation
Attribute
Comment
Method invocation
Chunk
Conflicting content 
    return null;
  }

<<<<<<< HEAD
=======
  @Override
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
  public Collection getAnnotations() {
    return Collections.emptySet();
  }
Solution content 
    return null;
  }

  @Override
  public Collection getAnnotations() {
    return Collections.emptySet();
  }
File
ArrayClass.java
Developer's decision
Version 2
Kind of conflict
Annotation
Chunk
Conflicting content 
public class JavaLanguage extends LanguageImpl implements BytecodeLanguage, Constants {

  public static class JavaInstructionFactory implements SSAInstructionFactory {
<<<<<<< HEAD
    public SSAArrayLengthInstruction ArrayLengthInstruction(int iindex, int result, int arrayref) {
      return new SSAArrayLengthInstruction(iindex, result, arrayref) {
=======
    @Override
    public SSAArrayLengthInstruction ArrayLengthInstruction(int result, int arrayref) {
      return new SSAArrayLengthInstruction(result, arrayref) {
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
        @Override
        public Collection getExceptionTypes() {
          return getNullPointerException();
Solution content 
public class JavaLanguage extends LanguageImpl implements BytecodeLanguage, Constants {

  public static class JavaInstructionFactory implements SSAInstructionFactory {
    @Override
    public SSAArrayLengthInstruction ArrayLengthInstruction(int iindex, int result, int arrayref) {
      return new SSAArrayLengthInstruction(iindex, result, arrayref) {
        @Override
        public Collection getExceptionTypes() {
          return getNullPointerException();
File
JavaLanguage.java
Developer's decision
Combination
Kind of conflict
Annotation
Method invocation
Method signature
Return statement
Chunk
Conflicting content 
      };
    }

<<<<<<< HEAD
    public SSAArrayLoadInstruction ArrayLoadInstruction(int iindex, int result, int arrayref, int index, TypeReference declaredType) {
      return new SSAArrayLoadInstruction(iindex, result, arrayref, index, declaredType) {
=======
    @Override
    public SSAArrayLoadInstruction ArrayLoadInstruction(int result, int arrayref, int index, TypeReference declaredType) {
      return new SSAArrayLoadInstruction(result, arrayref, index, declaredType) {
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
        @Override
        public Collection getExceptionTypes() {
          return getArrayAccessExceptions();
Solution content 
      };
    }

    @Override
    public SSAArrayLoadInstruction ArrayLoadInstruction(int iindex, int result, int arrayref, int index, TypeReference declaredType) {
      return new SSAArrayLoadInstruction(iindex, result, arrayref, index, declaredType) {
        @Override
        public Collection getExceptionTypes() {
          return getArrayAccessExceptions();
File
JavaLanguage.java
Developer's decision
Combination
Kind of conflict
Annotation
Method invocation
Method signature
Return statement
Chunk
Conflicting content 
      };
    }

<<<<<<< HEAD
    public SSAArrayStoreInstruction ArrayStoreInstruction(int iindex, int arrayref, int index, int value, TypeReference declaredType) {
      return new SSAArrayStoreInstruction(iindex, arrayref, index, value, declaredType) {
=======
    @Override
    public SSAArrayStoreInstruction ArrayStoreInstruction(int arrayref, int index, int value, TypeReference declaredType) {
      return new SSAArrayStoreInstruction(arrayref, index, value, declaredType) {
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
        @Override
        public Collection getExceptionTypes() {
          if (typeIsPrimitive()) {
Solution content 
      };
    }

    @Override
    public SSAArrayStoreInstruction ArrayStoreInstruction(int iindex, int arrayref, int index, int value, TypeReference declaredType) {
      return new SSAArrayStoreInstruction(iindex, arrayref, index, value, declaredType) {
        @Override
        public Collection getExceptionTypes() {
          if (typeIsPrimitive()) {
File
JavaLanguage.java
Developer's decision
Combination
Kind of conflict
Annotation
Method invocation
Method signature
Return statement
Chunk
Conflicting content 
      };
    }

<<<<<<< HEAD
    public SSABinaryOpInstruction BinaryOpInstruction(int iindex, IBinaryOpInstruction.IOperator operator, boolean overflow, boolean unsigned,
=======
    @Override
    public SSABinaryOpInstruction BinaryOpInstruction(IBinaryOpInstruction.IOperator operator, boolean overflow, boolean unsigned,
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
        int result, int val1, int val2, boolean mayBeInteger) {
      assert !overflow;
      assert !unsigned;
Solution content 
      };
    }

    @Override
    public SSABinaryOpInstruction BinaryOpInstruction(int iindex, IBinaryOpInstruction.IOperator operator, boolean overflow, boolean unsigned,
        int result, int val1, int val2, boolean mayBeInteger) {
      assert !overflow;
      assert !unsigned;
File
JavaLanguage.java
Developer's decision
Combination
Kind of conflict
Annotation
Method signature
Chunk
Conflicting content 
      };
    }

<<<<<<< HEAD
    public SSACheckCastInstruction CheckCastInstruction(int iindex, int result, int val, int[] typeValues, boolean isPEI) {
      throw new UnsupportedOperationException();
    }
       
    public SSACheckCastInstruction CheckCastInstruction(int iindex, int result, int val, TypeReference[] types, boolean isPEI) {
=======
    @Override
    public SSACheckCastInstruction CheckCastInstruction(int result, int val, int[] typeValues, boolean isPEI) {
      throw new UnsupportedOperationException();
    }
       
    @Override
    public SSACheckCastInstruction CheckCastInstruction(int result, int val, TypeReference[] types, boolean isPEI) {
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
       assert types.length == 1;
       assert isPEI;
      return new SSACheckCastInstruction(iindex, result, val, types, true) {
Solution content 
      };
    }

    @Override
    public SSACheckCastInstruction CheckCastInstruction(int iindex, int result, int val, int[] typeValues, boolean isPEI) {
      throw new UnsupportedOperationException();
    }
       
    @Override
    public SSACheckCastInstruction CheckCastInstruction(int iindex, int result, int val, TypeReference[] types, boolean isPEI) {
       assert types.length == 1;
       assert isPEI;
      return new SSACheckCastInstruction(iindex, result, val, types, true) {
File
JavaLanguage.java
Developer's decision
Combination
Kind of conflict
Annotation
Method declaration
Method signature
Chunk
Conflicting content 
      };
    }
     
<<<<<<< HEAD
    public SSACheckCastInstruction CheckCastInstruction(int iindex, int result, int val, int typeValue, boolean isPEI) {
=======
    @Override
    public SSACheckCastInstruction CheckCastInstruction(int result, int val, int typeValue, boolean isPEI) {
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
      assert isPEI;
      return CheckCastInstruction(iindex, result, val, new int[]{ typeValue }, true);
    }
Solution content 
      };
    }
     
    @Override
    public SSACheckCastInstruction CheckCastInstruction(int iindex, int result, int val, int typeValue, boolean isPEI) {
      assert isPEI;
      return CheckCastInstruction(iindex, result, val, new int[]{ typeValue }, true);
    }
File
JavaLanguage.java
Developer's decision
Combination
Kind of conflict
Annotation
Method signature
Chunk
Conflicting content 
      return CheckCastInstruction(iindex, result, val, new int[]{ typeValue }, true);
    }

<<<<<<< HEAD
    public SSACheckCastInstruction CheckCastInstruction(int iindex, int result, int val, TypeReference type, boolean isPEI) {
=======
    @Override
    public SSACheckCastInstruction CheckCastInstruction(int result, int val, TypeReference type, boolean isPEI) {
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
      assert isPEI;
      return CheckCastInstruction(iindex, result, val, new TypeReference[]{ type }, true);
    }
Solution content 
      return CheckCastInstruction(iindex, result, val, new int[]{ typeValue }, true);
    }

    @Override
    public SSACheckCastInstruction CheckCastInstruction(int iindex, int result, int val, TypeReference type, boolean isPEI) {
      assert isPEI;
      return CheckCastInstruction(iindex, result, val, new TypeReference[]{ type }, true);
    }
File
JavaLanguage.java
Developer's decision
Combination
Kind of conflict
Annotation
Method signature
Chunk
Conflicting content 
      return CheckCastInstruction(iindex, result, val, new TypeReference[]{ type }, true);
    }

<<<<<<< HEAD
    public SSAComparisonInstruction ComparisonInstruction(int iindex, IComparisonInstruction.Operator operator, int result, int val1, int val2) {
      return new SSAComparisonInstruction(iindex, operator, result, val1, val2);
    }

    public SSAConditionalBranchInstruction ConditionalBranchInstruction(int iindex, IConditionalBranchInstruction.IOperator operator,
=======
    @Override
    public SSAComparisonInstruction ComparisonInstruction(IComparisonInstruction.Operator operator, int result, int val1, int val2) {
      return new SSAComparisonInstruction(operator, result, val1, val2);
    }

    @Override
    public SSAConditionalBranchInstruction ConditionalBranchInstruction(IConditionalBranchInstruction.IOperator operator,
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
        TypeReference type, int val1, int val2) {
      return new SSAConditionalBranchInstruction(iindex, operator, type, val1, val2);
    }
Solution content 
      return CheckCastInstruction(iindex, result, val, new TypeReference[]{ type }, true);
    }

    @Override
    public SSAComparisonInstruction ComparisonInstruction(int iindex, IComparisonInstruction.Operator operator, int result, int val1, int val2) {
      return new SSAComparisonInstruction(iindex, operator, result, val1, val2);
    }

    @Override
    public SSAConditionalBranchInstruction ConditionalBranchInstruction(int iindex, IConditionalBranchInstruction.IOperator operator,
        TypeReference type, int val1, int val2) {
      return new SSAConditionalBranchInstruction(iindex, operator, type, val1, val2);
    }
File
JavaLanguage.java
Developer's decision
Combination
Kind of conflict
Annotation
Method declaration
Method signature
Chunk
Conflicting content 
      return new SSAConditionalBranchInstruction(iindex, operator, type, val1, val2);
    }

<<<<<<< HEAD
    public SSAConversionInstruction ConversionInstruction(int iindex, int result, int val, TypeReference fromType, TypeReference toType,
=======
    @Override
    public SSAConversionInstruction ConversionInstruction(int result, int val, TypeReference fromType, TypeReference toType,
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
        boolean overflow) {
      assert !overflow;
      return new SSAConversionInstruction(iindex, result, val, fromType, toType) {
Solution content 
      return new SSAConditionalBranchInstruction(iindex, operator, type, val1, val2);
    }

    @Override
    public SSAConversionInstruction ConversionInstruction(int iindex, int result, int val, TypeReference fromType, TypeReference toType,
        boolean overflow) {
      assert !overflow;
      return new SSAConversionInstruction(iindex, result, val, fromType, toType) {
File
JavaLanguage.java
Developer's decision
Combination
Kind of conflict
Annotation
Method signature
Chunk
Conflicting content 
      };
    }

<<<<<<< HEAD
    public SSAGetCaughtExceptionInstruction GetCaughtExceptionInstruction(int iindex, int bbNumber, int exceptionValueNumber) {
      return new SSAGetCaughtExceptionInstruction(iindex, bbNumber, exceptionValueNumber);
    }

    public SSAGetInstruction GetInstruction(int iindex, int result, FieldReference field) {
      return new SSAGetInstruction(iindex, result, field) {
      };
    }

    public SSAGetInstruction GetInstruction(int iindex, int result, int ref, FieldReference field) {
      return new SSAGetInstruction(iindex, result, ref, field) {
=======
    @Override
    public SSAGetCaughtExceptionInstruction GetCaughtExceptionInstruction(int bbNumber, int exceptionValueNumber) {
      return new SSAGetCaughtExceptionInstruction(bbNumber, exceptionValueNumber);
    }

    @Override
    public SSAGetInstruction GetInstruction(int result, FieldReference field) {
      return new SSAGetInstruction(result, field) {
      };
    }

    @Override
    public SSAGetInstruction GetInstruction(int result, int ref, FieldReference field) {
      return new SSAGetInstruction(result, ref, field) {
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
        @Override
        public Collection getExceptionTypes() {
          return getNullPointerException();
Solution content 
      };
    }

    @Override
    public SSAGetCaughtExceptionInstruction GetCaughtExceptionInstruction(int iindex, int bbNumber, int exceptionValueNumber) {
      return new SSAGetCaughtExceptionInstruction(iindex, bbNumber, exceptionValueNumber);
    }

    @Override
    public SSAGetInstruction GetInstruction(int iindex, int result, FieldReference field) {
      return new SSAGetInstruction(iindex, result, field) {
      };
    }

    @Override
    public SSAGetInstruction GetInstruction(int iindex, int result, int ref, FieldReference field) {
      return new SSAGetInstruction(iindex, result, ref, field) {
        @Override
        public Collection getExceptionTypes() {
          return getNullPointerException();
File
JavaLanguage.java
Developer's decision
Combination
Kind of conflict
Annotation
Method declaration
Method invocation
Method signature
Return statement
Chunk
Conflicting content 
      };
    }

<<<<<<< HEAD
    public SSAGotoInstruction GotoInstruction(int iindex) {
      return new SSAGotoInstruction(iindex);
    }

    public SSAInstanceofInstruction InstanceofInstruction(int iindex, int result, int ref, TypeReference checkedType) {
      return new SSAInstanceofInstruction(iindex, result, ref, checkedType);
    }

    public SSAInvokeInstruction InvokeInstruction(int iindex, int result, int[] params, int exception, CallSiteReference site) {
      return new SSAInvokeInstruction(iindex, result, params, exception, site) {
=======
    @Override
    public SSAGotoInstruction GotoInstruction() {
      return new SSAGotoInstruction();
    }

    @Override
    public SSAInstanceofInstruction InstanceofInstruction(int result, int ref, TypeReference checkedType) {
      return new SSAInstanceofInstruction(result, ref, checkedType);
    }

    @Override
    public SSAInvokeInstruction InvokeInstruction(int result, int[] params, int exception, CallSiteReference site) {
      return new SSAInvokeInstruction(result, params, exception, site) {
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
        @Override
        public Collection getExceptionTypes() {
          if (!isStatic()) {
Solution content 
      };
    }

    @Override
    public SSAGotoInstruction GotoInstruction(int iindex) {
      return new SSAGotoInstruction(iindex);
    }

    @Override
    public SSAInstanceofInstruction InstanceofInstruction(int iindex, int result, int ref, TypeReference checkedType) {
      return new SSAInstanceofInstruction(iindex, result, ref, checkedType);
    }

    @Override
    public SSAInvokeInstruction InvokeInstruction(int iindex, int result, int[] params, int exception, CallSiteReference site) {
      return new SSAInvokeInstruction(iindex, result, params, exception, site) {
        @Override
        public Collection getExceptionTypes() {
          if (!isStatic()) {
File
JavaLanguage.java
Developer's decision
Combination
Kind of conflict
Annotation
Method declaration
Method invocation
Method signature
Return statement
Chunk
Conflicting content 
      };
    }

<<<<<<< HEAD
    public SSAInvokeInstruction InvokeInstruction(int iindex, int[] params, int exception, CallSiteReference site) {
      return new SSAInvokeInstruction(iindex, params, exception, site) {
=======
    @Override
    public SSAInvokeInstruction InvokeInstruction(int[] params, int exception, CallSiteReference site) {
      return new SSAInvokeInstruction(params, exception, site) {
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
        @Override
        public Collection getExceptionTypes() {
          if (!isStatic()) {
Solution content 
      };
    }

    @Override
    public SSAInvokeInstruction InvokeInstruction(int iindex, int[] params, int exception, CallSiteReference site) {
      return new SSAInvokeInstruction(iindex, params, exception, site) {
        @Override
        public Collection getExceptionTypes() {
          if (!isStatic()) {
File
JavaLanguage.java
Developer's decision
Combination
Kind of conflict
Annotation
Method invocation
Method signature
Return statement
Chunk
Conflicting content 
      };
    }

<<<<<<< HEAD
    public SSAMonitorInstruction MonitorInstruction(int iindex, int ref, boolean isEnter) {
      return new SSAMonitorInstruction(iindex, ref, isEnter) {
=======
    @Override
    public SSAMonitorInstruction MonitorInstruction(int ref, boolean isEnter) {
      return new SSAMonitorInstruction(ref, isEnter) {
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
        @Override
        public Collection getExceptionTypes() {
          return getNullPointerException();
Solution content 
      };
    }

    @Override
    public SSAMonitorInstruction MonitorInstruction(int iindex, int ref, boolean isEnter) {
      return new SSAMonitorInstruction(iindex, ref, isEnter) {
        @Override
        public Collection getExceptionTypes() {
          return getNullPointerException();
File
JavaLanguage.java
Developer's decision
Combination
Kind of conflict
Annotation
Method invocation
Method signature
Return statement
Chunk
Conflicting content 
      };
    }

<<<<<<< HEAD
    public SSANewInstruction NewInstruction(int iindex, int result, NewSiteReference site) {
      return new SSANewInstruction(iindex, result, site) {
=======
    @Override
    public SSANewInstruction NewInstruction(int result, NewSiteReference site) {
      return new SSANewInstruction(result, site) {
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
        @Override
        public Collection getExceptionTypes() {
          if (getNewSite().getDeclaredType().isArrayType()) {
Solution content 
      };
    }

    @Override
    public SSANewInstruction NewInstruction(int iindex, int result, NewSiteReference site) {
      return new SSANewInstruction(iindex, result, site) {
        @Override
        public Collection getExceptionTypes() {
          if (getNewSite().getDeclaredType().isArrayType()) {
File
JavaLanguage.java
Developer's decision
Combination
Kind of conflict
Annotation
Method invocation
Method signature
Return statement
Chunk
Conflicting content 
      };
    }

<<<<<<< HEAD
    public SSAPhiInstruction PhiInstruction(int iindex, int result, int[] params) throws IllegalArgumentException {
      return new SSAPhiInstruction(iindex, result, params) {
      };
    }

    public SSAPutInstruction PutInstruction(int iindex, int ref, int value, FieldReference field) {
      return new SSAPutInstruction(iindex, ref, value, field) {
=======
    @Override
    public SSAPhiInstruction PhiInstruction(int result, int[] params) throws IllegalArgumentException {
      return new SSAPhiInstruction(result, params) {
      };
    }

    @Override
    public SSAPutInstruction PutInstruction(int ref, int value, FieldReference field) {
      return new SSAPutInstruction(ref, value, field) {
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
        @Override
        public Collection getExceptionTypes() {
          return getNullPointerException();
Solution content 
      };
    }

    @Override
    public SSAPhiInstruction PhiInstruction(int iindex, int result, int[] params) throws IllegalArgumentException {
      return new SSAPhiInstruction(iindex, result, params) {
      };
    }

    @Override
    public SSAPutInstruction PutInstruction(int iindex, int ref, int value, FieldReference field) {
      return new SSAPutInstruction(iindex, ref, value, field) {
        @Override
        public Collection getExceptionTypes() {
          return getNullPointerException();
File
JavaLanguage.java
Developer's decision
Combination
Kind of conflict
Annotation
Method declaration
Method invocation
Method signature
Return statement
Chunk
Conflicting content 
      };
    }

<<<<<<< HEAD
    public SSAPutInstruction PutInstruction(int iindex, int value, FieldReference field) {
      return new SSAPutInstruction(iindex, value, field) {
      };
    }

    public SSAReturnInstruction ReturnInstruction(int iindex) {
      return new SSAReturnInstruction(iindex);
    }

    public SSAReturnInstruction ReturnInstruction(int iindex, int result, boolean isPrimitive) {
      return new SSAReturnInstruction(iindex, result, isPrimitive);
    }

    public SSASwitchInstruction SwitchInstruction(int iindex, int val, int defaultLabel, int[] casesAndLabels) {
      return new SSASwitchInstruction(iindex, val, defaultLabel, casesAndLabels);
    }

    public SSAThrowInstruction ThrowInstruction(int iindex, int exception) {
      return new SSAThrowInstruction(iindex, exception) {
=======
    @Override
    public SSAPutInstruction PutInstruction(int value, FieldReference field) {
      return new SSAPutInstruction(value, field) {
      };
    }

    @Override
    public SSAReturnInstruction ReturnInstruction() {
      return new SSAReturnInstruction();
    }

    @Override
    public SSAReturnInstruction ReturnInstruction(int result, boolean isPrimitive) {
      return new SSAReturnInstruction(result, isPrimitive);
    }

    @Override
    public SSASwitchInstruction SwitchInstruction(int val, int defaultLabel, int[] casesAndLabels) {
      return new SSASwitchInstruction(val, defaultLabel, casesAndLabels);
    }

    @Override
    public SSAThrowInstruction ThrowInstruction(int exception) {
      return new SSAThrowInstruction(exception) {
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
        @Override
        public Collection getExceptionTypes() {
          return getNullPointerException();
Solution content 
      };
    }

    @Override
    public SSAPutInstruction PutInstruction(int iindex, int value, FieldReference field) {
      return new SSAPutInstruction(iindex, value, field) {
      };
    }

    @Override
    public SSAReturnInstruction ReturnInstruction(int iindex) {
      return new SSAReturnInstruction(iindex);
    }

    @Override
    public SSAReturnInstruction ReturnInstruction(int iindex, int result, boolean isPrimitive) {
      return new SSAReturnInstruction(iindex, result, isPrimitive);
    }

    @Override
    public SSASwitchInstruction SwitchInstruction(int iindex, int val, int defaultLabel, int[] casesAndLabels) {
      return new SSASwitchInstruction(iindex, val, defaultLabel, casesAndLabels);
    }

    @Override
    public SSAThrowInstruction ThrowInstruction(int iindex, int exception) {
      return new SSAThrowInstruction(iindex, exception) {
        @Override
        public Collection getExceptionTypes() {
          return getNullPointerException();
File
JavaLanguage.java
Developer's decision
Combination
Kind of conflict
Annotation
Method declaration
Method invocation
Method signature
Return statement
Chunk
Conflicting content 
      };
    }

<<<<<<< HEAD
    public SSAUnaryOpInstruction UnaryOpInstruction(int iindex, IUnaryOpInstruction.IOperator operator, int result, int val) {
      return new SSAUnaryOpInstruction(iindex, operator, result, val);
    }

    public SSALoadMetadataInstruction LoadMetadataInstruction(int iindex, int lval, TypeReference entityType, Object token) {
      return new SSALoadMetadataInstruction(iindex, lval, entityType, token) {
=======
    @Override
    public SSAUnaryOpInstruction UnaryOpInstruction(IUnaryOpInstruction.IOperator operator, int result, int val) {
      return new SSAUnaryOpInstruction(operator, result, val);
    }

    @Override
    public SSALoadMetadataInstruction LoadMetadataInstruction(int lval, TypeReference entityType, Object token) {
      return new SSALoadMetadataInstruction(lval, entityType, token) {
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
        @Override
        public Collection getExceptionTypes() {
          return loadClassExceptions;
Solution content 
      };
    }

    @Override
    public SSAUnaryOpInstruction UnaryOpInstruction(int iindex, IUnaryOpInstruction.IOperator operator, int result, int val) {
      return new SSAUnaryOpInstruction(iindex, operator, result, val);
    }

    @Override
    public SSALoadMetadataInstruction LoadMetadataInstruction(int iindex, int lval, TypeReference entityType, Object token) {
      return new SSALoadMetadataInstruction(iindex, lval, entityType, token) {
        @Override
        public Collection getExceptionTypes() {
          return loadClassExceptions;
File
JavaLanguage.java
Developer's decision
Combination
Kind of conflict
Annotation
Method declaration
Method invocation
Method signature
Return statement
Chunk
Conflicting content 
      };
    }

<<<<<<< HEAD
    public SSANewInstruction NewInstruction(int iindex, int result, NewSiteReference site, int[] params) {
      return new SSANewInstruction(iindex, result, site, params) {
=======
    @Override
    public SSANewInstruction NewInstruction(int result, NewSiteReference site, int[] params) {
      return new SSANewInstruction(result, site, params) {
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
        @Override
        public Collection getExceptionTypes() {
          return getNewArrayExceptions();
Solution content 
      };
    }

    @Override
    public SSANewInstruction NewInstruction(int iindex, int result, NewSiteReference site, int[] params) {
      return new SSANewInstruction(iindex, result, site, params) {
        @Override
        public Collection getExceptionTypes() {
          return getNewArrayExceptions();
File
JavaLanguage.java
Developer's decision
Combination
Kind of conflict
Annotation
Method invocation
Method signature
Return statement
Chunk
Conflicting content 
      };
    }

<<<<<<< HEAD
    public SSAPiInstruction PiInstruction(int iindex, int result, int val, int piBlock, int successorBlock, SSAInstruction cause) {
      return new SSAPiInstruction(iindex, result, val, piBlock, successorBlock, cause);
    }

    public SSAAddressOfInstruction AddressOfInstruction(int iindex, int lval, int local, TypeReference pointeeType) {
      throw new UnsupportedOperationException();
    }

    public SSAAddressOfInstruction AddressOfInstruction(int iindex, int lval, int local, int indexVal, TypeReference pointeeType) {
      throw new UnsupportedOperationException();
   }

    public SSAAddressOfInstruction AddressOfInstruction(int iindex, int lval, int local, FieldReference field, TypeReference pointeeType) {
      throw new UnsupportedOperationException();
    }

    public SSALoadIndirectInstruction LoadIndirectInstruction(int iindex, int lval, TypeReference t, int addressVal) {
      throw new UnsupportedOperationException();
    }

    public SSAStoreIndirectInstruction StoreIndirectInstruction(int iindex, int addressVal, int rval, TypeReference pointeeType) {
=======
    @Override
    public SSAPiInstruction PiInstruction(int result, int val, int piBlock, int successorBlock, SSAInstruction cause) {
      return new SSAPiInstruction(result, val, piBlock, successorBlock, cause);
    }

    @Override
    public SSAAddressOfInstruction AddressOfInstruction(int lval, int local, TypeReference pointeeType) {
      throw new UnsupportedOperationException();
    }

    @Override
    public SSAAddressOfInstruction AddressOfInstruction(int lval, int local, int indexVal, TypeReference pointeeType) {
      throw new UnsupportedOperationException();
   }

    @Override
    public SSAAddressOfInstruction AddressOfInstruction(int lval, int local, FieldReference field, TypeReference pointeeType) {
      throw new UnsupportedOperationException();
    }

    @Override
    public SSALoadIndirectInstruction LoadIndirectInstruction(int lval, TypeReference t, int addressVal) {
      throw new UnsupportedOperationException();
    }

    @Override
    public SSAStoreIndirectInstruction StoreIndirectInstruction(int addressVal, int rval, TypeReference pointeeType) {
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
      throw new UnsupportedOperationException();
    }
  }
Solution content 
      };
    }

    @Override
    public SSAPiInstruction PiInstruction(int iindex, int result, int val, int piBlock, int successorBlock, SSAInstruction cause) {
      return new SSAPiInstruction(iindex, result, val, piBlock, successorBlock, cause);
    }

    @Override
    public SSAAddressOfInstruction AddressOfInstruction(int iindex, int lval, int local, TypeReference pointeeType) {
      throw new UnsupportedOperationException();
    }

    @Override
    public SSAAddressOfInstruction AddressOfInstruction(int iindex, int lval, int local, int indexVal, TypeReference pointeeType) {
      throw new UnsupportedOperationException();
   }

    @Override
    public SSAAddressOfInstruction AddressOfInstruction(int iindex, int lval, int local, FieldReference field, TypeReference pointeeType) {
      throw new UnsupportedOperationException();
    }

    @Override
    public SSALoadIndirectInstruction LoadIndirectInstruction(int iindex, int lval, TypeReference t, int addressVal) {
      throw new UnsupportedOperationException();
    }

    @Override
    public SSAStoreIndirectInstruction StoreIndirectInstruction(int iindex, int addressVal, int rval, TypeReference pointeeType) {
      throw new UnsupportedOperationException();
    }
  }
File
JavaLanguage.java
Developer's decision
Combination
Kind of conflict
Annotation
Method declaration
Method signature
Chunk
Conflicting content 
    }
  }

<<<<<<< HEAD
  public InputStream getInputStream(String name) {
    populateCache();
    byte[] b = cache.get(name);
    return new ByteArrayInputStream(b);
  }

  private void populateCache() {
    if (cache != null) {
      return;
    }
    cache = HashMapFactory.make();
    final byte[] b = parent.getContents(entry);
    try {
      final JarInputStream stream = new JarInputStream(new ByteArrayInputStream(b));
      for (ZipEntry z = stream.getNextEntry(); z != null; z = stream.getNextEntry()) {
        final String name = z.getName();
        if (DEBUG) {
    }
          System.err.println(("got entry: " + name));
        }
        if (FileSuffixes.isClassFile(name) || FileSuffixes.isSourceFile(name)) {
          ByteArrayOutputStream out = new ByteArrayOutputStream();
          byte[] temp = new byte[1024];
          int n = stream.read(temp);
          while (n != -1) {
            out.write(temp, 0, n);
            n = stream.read(temp);
          }
          byte[] bb = out.toByteArray();
          cache.put(name, bb);
        }
      }
      stream.close();
    } catch (IOException e) {
      // just go with what we have
      Warnings.add(new Warning() {

        @Override
        public String getMsg() {
          return "could not read contents of nested jar file " + entry.getName() + ", parent " + parent.getAbsolutePath();
        }
      });
    }

  }

  protected long getEntrySize(String name) {
    populateCache();
    byte[] b = cache.get(name);
    return b.length;
  }

  /*
   * @see com.ibm.wala.classLoader.Module#getEntries()
   */
  public Iterator getEntries() {
    populateCache();
    final Iterator it = cache.keySet().iterator();
    return new Iterator() {
      String next = null;
      {
        advance();
      }

      private void advance() {
        if (it.hasNext()) {
          next = it.next();
        } else {
          next = null;
        }
      }

      public boolean hasNext() {
        return next != null;
      }

      public ModuleEntry next() {
        ModuleEntry result = new Entry(next);
        advance();
        return result;
      }

      public void remove() {
        Assertions.UNREACHABLE();
      }
    };
  }

  /**
   * @author sfink an entry in a nested jar file.
   */
  private class Entry implements ModuleEntry {

    private final String name;

    Entry(String name) {
      this.name = name;
    }

    /*
     * @see com.ibm.wala.classLoader.ModuleEntry#getName()
     */
    public String getName() {
      return name;
    }

    /*
     * @see com.ibm.wala.classLoader.ModuleEntry#isClassFile()
     */
    public boolean isClassFile() {
      return FileSuffixes.isClassFile(getName());
    }

    /*
     * @see com.ibm.wala.classLoader.ModuleEntry#getInputStream()
     */
    public InputStream getInputStream() {
      return NestedJarFileModule.this.getInputStream(name);
    }

    /*
     * @see com.ibm.wala.classLoader.ModuleEntry#isModuleFile()
     */
    public boolean isModuleFile() {
      return false;
    }

    /*
     * @see com.ibm.wala.classLoader.ModuleEntry#asModule()
     */
    public Module asModule() {
      Assertions.UNREACHABLE();
      return null;

    @Override
    public String toString() {
      return "nested entry: " + name;
    }

    /*
     * @see com.ibm.wala.classLoader.ModuleEntry#getClassName()
     */
    public String getClassName() {
      return FileSuffixes.stripSuffix(getName());
    }

    /*
     * @see com.ibm.wala.classLoader.ModuleEntry#isSourceFile()
     */
    public boolean isSourceFile() {
      return FileSuffixes.isSourceFile(getName());
    }

    @Override
    public int hashCode() {
      final int prime = 31;
      int result = 1;
      result = prime * result + getOuterType().hashCode();
      result = prime * result + ((name == null) ? 0 : name.hashCode());
      return result;
    }

    @Override
    public boolean equals(Object obj) {
      if (this == obj)
        return true;
      if (obj == null)
        return false;
      if (getClass() != obj.getClass())
        return false;
      Entry other = (Entry) obj;
      if (!getOuterType().equals(other.getOuterType()))
        return false;
      if (name == null) {
        if (other.name != null)
          return false;
      } else if (!name.equals(other.name))
        return false;
      return true;
    }

    private NestedJarFileModule getOuterType() {
      return NestedJarFileModule.this;
    }

=======
  @Override
  protected InputStream getNestedContents() {
    return new ByteArrayInputStream(parent.getContents(entry));
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
  }

  @Override
Solution content 
    }
  }

  @Override
  protected InputStream getNestedContents() {
    return new ByteArrayInputStream(parent.getContents(entry));
  }

  @Override
File
NestedJarFileModule.java
Developer's decision
Version 2
Kind of conflict
Annotation
Attribute
Class signature
Comment
Method declaration
Method invocation
Method signature
Return statement
Chunk
Conflicting content 
import com.ibm.wala.shrikeCT.LineNumberTableReader;
import com.ibm.wala.shrikeCT.LocalVariableTableReader;
import com.ibm.wala.shrikeCT.SignatureReader;
<<<<<<< HEAD
import com.ibm.wala.shrikeCT.SourcePositionTableReader;
import com.ibm.wala.shrikeCT.SourcePositionTableReader.Position;
=======
import com.ibm.wala.types.ClassLoaderReference;
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
import com.ibm.wala.types.TypeReference;
import com.ibm.wala.types.annotations.Annotation;
import com.ibm.wala.types.generics.MethodTypeSignature;
Solution content 
import com.ibm.wala.shrikeCT.LineNumberTableReader;
import com.ibm.wala.shrikeCT.LocalVariableTableReader;
import com.ibm.wala.shrikeCT.SignatureReader;
import com.ibm.wala.shrikeCT.SourcePositionTableReader;
import com.ibm.wala.shrikeCT.SourcePositionTableReader.Position;
import com.ibm.wala.types.ClassLoaderReference;
import com.ibm.wala.types.TypeReference;
import com.ibm.wala.types.annotations.Annotation;
import com.ibm.wala.types.generics.MethodTypeSignature;
File
ShrikeCTMethod.java
Developer's decision
Concatenation
Kind of conflict
Import
Chunk
Conflicting content 
    return Annotation.getAnnotationsFromReader(r, getDeclaringClass().getClassLoader().getReference());
  }

<<<<<<< HEAD
=======
  @Override
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
  public Collection getAnnotations() {
    Collection result = HashSetFactory.make();
    try {
Solution content 
    return Annotation.getAnnotationsFromReader(r, getDeclaringClass().getClassLoader().getReference());
  }

  @Override
  public Collection getAnnotations() {
    Collection result = HashSetFactory.make();
    try {
File
ShrikeCTMethod.java
Developer's decision
Version 2
Kind of conflict
Annotation
Chunk
Conflicting content 
  public Collection getRuntimeVisibleAnnotations() throws InvalidClassFileException {
    return getAnnotations(false);
  }
<<<<<<< HEAD
  
=======

  @Override
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
  public Collection getAnnotations() {
    Collection result = HashSetFactory.make();
    try {
Solution content 
  public Collection getRuntimeVisibleAnnotations() throws InvalidClassFileException {
    return getAnnotations(false);
  }

  @Override
  public Collection getAnnotations() {
    Collection result = HashSetFactory.make();
    try {
File
ShrikeClass.java
Developer's decision
Version 2
Kind of conflict
Annotation
Chunk
Conflicting content 
      result.addAll(getAnnotations(true));
      result.addAll(getAnnotations(false));
    } catch (InvalidClassFileException e) {
<<<<<<< HEAD
      
=======

>>>>>>> b984760100e3be325d458f61b0d556f479701c95
    }
    return result;
  }
Solution content 
      result.addAll(getAnnotations(true));
      result.addAll(getAnnotations(false));
    } catch (InvalidClassFileException e) {

    }
    return result;
  }
File
ShrikeClass.java
Developer's decision
Version 1
Kind of conflict
Blank
Chunk
Conflicting content 
    return getField(name);
  }

<<<<<<< HEAD
=======
  @Override
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
  public Collection getAnnotations() {
    return Collections.emptySet();
  }
Solution content 
    return getField(name);
  }

  @Override
  public Collection getAnnotations() {
    return Collections.emptySet();
  }
File
SyntheticClass.java
Developer's decision
Version 2
Kind of conflict
Annotation
Chunk
Conflicting content 
    return getDeclaringClass().getClassHierarchy();
  }

<<<<<<< HEAD
=======
  @Override
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
  public Collection getAnnotations() {
     return Collections.emptySet();
  }
Solution content 
    return getDeclaringClass().getClassHierarchy();
  }

  @Override
  public Collection getAnnotations() {
     return Collections.emptySet();
  }
File
SyntheticMethod.java
Developer's decision
Version 2
Kind of conflict
Annotation
Chunk
Conflicting content 
    return builder;
  }

<<<<<<< HEAD
  @SuppressWarnings("unchecked")
=======
  @Override
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
  public void setModuleFiles(Collection moduleFiles) {
    this.moduleFiles = moduleFiles;
  }
Solution content 
  @Override
    return builder;
  }

  @SuppressWarnings("unchecked")
  public void setModuleFiles(Collection moduleFiles) {
    this.moduleFiles = moduleFiles;
  }
File
AbstractAnalysisEngine.java
Developer's decision
Concatenation
Kind of conflict
Annotation
Chunk
Conflicting content 
   * 
   * @see com.ibm.wala.dataflow.IFDS.ISupergraph#getCalledNodes(java.lang.Object)
   */
<<<<<<< HEAD
  @SuppressWarnings("unused")
=======
  @Override
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
  public Iterator getCalledNodes(T ret) {
    if (DEBUG_LEVEL > 1) {
      System.err.println(getClass() + " getCalledNodes " + ret);
Solution content 
   * 
   * @see com.ibm.wala.dataflow.IFDS.ISupergraph#getCalledNodes(java.lang.Object)
   */
  @SuppressWarnings("unused")
  @Override
  public Iterator getCalledNodes(T ret) {
    if (DEBUG_LEVEL > 1) {
      System.err.println(getClass() + " getCalledNodes " + ret);
File
BackwardsSupergraph.java
Developer's decision
Concatenation
Kind of conflict
Annotation
Chunk
Conflicting content 
    return null;
  }

<<<<<<< HEAD
=======
  @Override
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
  public Collection getAnnotations() {
    return Collections.emptySet();
  }
Solution content 
    return null;
  }

  @Override
  public Collection getAnnotations() {
    return Collections.emptySet();
  }
File
ArrayContents.java
Developer's decision
Version 2
Kind of conflict
Annotation
Chunk
Conflicting content 
/**
 * A call graph which explicitly holds the target for each call site in each node.
 */
<<<<<<< HEAD
@SuppressWarnings("deprecation")
public class ExplicitCallGraph extends BasicCallGraph implements BytecodeConstants {
=======
public class ExplicitCallGraph extends BasicCallGraph implements BytecodeConstants {
>>>>>>> b984760100e3be325d458f61b0d556f479701c95

  protected final IClassHierarchy cha;
Solution content 
/**
 * A call graph which explicitly holds the target for each call site in each node.
 */
@SuppressWarnings("deprecation")
public class ExplicitCallGraph extends BasicCallGraph implements BytecodeConstants {

  protected final IClassHierarchy cha;
File
ExplicitCallGraph.java
Developer's decision
Combination
Kind of conflict
Annotation
Class signature
Chunk
Conflicting content 
        return false;
      }

<<<<<<< HEAD
=======
      @Override
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
      public Collection getAnnotations() {
        return Collections.emptySet();
      }
Solution content 
        return false;
      }

      @Override
      public Collection getAnnotations() {
        return Collections.emptySet();
      }
File
FakeRootClass.java
Developer's decision
Version 2
Kind of conflict
Annotation
Chunk
Conflicting content 
    return true;
  }

<<<<<<< HEAD
=======
  @Override
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
  public Iterator> getCreationSites(CallGraph CG) {
    return new MapIterator>(
        new FilterIterator(
Solution content 
    return true;
  }

  @Override
  public Iterator> getCreationSites(CallGraph CG) {
    return new MapIterator>(
        new FilterIterator(
File
AllocationSite.java
Developer's decision
Version 2
Kind of conflict
Annotation
Chunk
Conflicting content 
        new FilterIterator(
          CG.getNodes(method.getReference()).iterator(),
          new Filter() {
<<<<<<< HEAD
=======
            @Override
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
            public boolean accepts(CGNode o) {
              return o.getMethod().equals(method);
            }
Solution content 
        new FilterIterator(
          CG.getNodes(method.getReference()).iterator(),
          new Filter() {
            @Override
            public boolean accepts(CGNode o) {
              return o.getMethod().equals(method);
            }
File
AllocationSite.java
Developer's decision
Version 2
Kind of conflict
Annotation
Chunk
Conflicting content 
          }
        ), 
        new Function>() {
<<<<<<< HEAD
=======
          @Override
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
          public Pair apply(CGNode object) {
            return Pair.make(object, site);
          }
Solution content 
          }
        ), 
        new Function>() {
          @Override
          public Pair apply(CGNode object) {
            return Pair.make(object, site);
          }
File
AllocationSite.java
Developer's decision
Version 2
Kind of conflict
Annotation
Chunk
Conflicting content 
    return site;
  }

<<<<<<< HEAD
=======
  @Override
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
  public Iterator> getCreationSites(CallGraph CG) {
    return new NonNullSingletonIterator>(Pair.make(getNode(), getSite()));
  }
Solution content 
    return site;
  }

  @Override
  public Iterator> getCreationSites(CallGraph CG) {
    return new NonNullSingletonIterator>(Pair.make(getNode(), getSite()));
  }
File
AllocationSiteInNode.java
Developer's decision
Version 2
Kind of conflict
Annotation
Chunk
Conflicting content 
    return result;
  }

<<<<<<< HEAD
=======
  @Override
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
  public Iterator> getCreationSites(CallGraph CG) {
    return new ComposedIterator>(CG.iterator()) {
      @Override
Solution content 
    return result;
  }

  @Override
  public Iterator> getCreationSites(CallGraph CG) {
    return new ComposedIterator>(CG.iterator()) {
      @Override
File
ConcreteTypeKey.java
Developer's decision
Version 2
Kind of conflict
Annotation
Chunk
Conflicting content 
            new FilterIterator(
                outer.iterateNewSites(),
                new Filter() {
<<<<<<< HEAD
=======
                  @Override
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
                  public boolean accepts(NewSiteReference o) {
                    return o.getDeclaredType().equals(type.getReference());
                  }
Solution content 
            new FilterIterator(
                outer.iterateNewSites(),
                new Filter() {
                  @Override
                  public boolean accepts(NewSiteReference o) {
                    return o.getDeclaredType().equals(type.getReference());
                  }
File
ConcreteTypeKey.java
Developer's decision
Version 2
Kind of conflict
Annotation
Chunk
Conflicting content 
                }
            ),
            new Function>() {
<<<<<<< HEAD
=======
              @Override
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
              public Pair apply(NewSiteReference object) {
                return Pair.make(outer, object);
              }
Solution content 
            ),
                }
            new Function>() {
              @Override
              public Pair apply(NewSiteReference object) {
                return Pair.make(outer, object);
              }
File
ConcreteTypeKey.java
Developer's decision
Version 2
Kind of conflict
Annotation
Chunk
Conflicting content 
    return value;
  }

<<<<<<< HEAD
=======
  @Override
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
  public Iterator> getCreationSites(CallGraph CG) {
    return EmptyIterator.instance();
  }
Solution content 
    return value;
  }

  @Override
  public Iterator> getCreationSites(CallGraph CG) {
    return EmptyIterator.instance();
  }
File
ConstantKey.java
Developer's decision
Version 2
Kind of conflict
Annotation
Chunk
Conflicting content 
    return "SMUSHED " + getNode() + " : " + getConcreteType();
  }

<<<<<<< HEAD
=======
  @Override
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
  public Iterator> getCreationSites(CallGraph CG) {
    return new MapIterator>(
        new FilterIterator(
Solution content 
    return "SMUSHED " + getNode() + " : " + getConcreteType();
  }

  @Override
  public Iterator> getCreationSites(CallGraph CG) {
    return new MapIterator>(
        new FilterIterator(
File
SmushedAllocationSiteInNode.java
Developer's decision
Version 2
Kind of conflict
Annotation
Chunk
Conflicting content 
        new FilterIterator(
          getNode().iterateNewSites(),
          new Filter() {
<<<<<<< HEAD
=======
            @Override
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
            public boolean accepts(NewSiteReference o) {
              return o.getDeclaredType().equals(getConcreteType().getReference());
            }
Solution content 
        new FilterIterator(
          getNode().iterateNewSites(),
          new Filter() {
            @Override
            public boolean accepts(NewSiteReference o) {
              return o.getDeclaredType().equals(getConcreteType().getReference());
            }
File
SmushedAllocationSiteInNode.java
Developer's decision
Version 2
Kind of conflict
Annotation
Chunk
Conflicting content 
            }
        }),
        new Function>() {
<<<<<<< HEAD
=======
          @Override
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
          public Pair apply(NewSiteReference object) {
            return Pair.make(getNode(), object);
          }
Solution content 
            }
        }),
        new Function>() {
          @Override
          public Pair apply(NewSiteReference object) {
            return Pair.make(getNode(), object);
          }
File
SmushedAllocationSiteInNode.java
Developer's decision
Version 2
Kind of conflict
Annotation
Chunk
Conflicting content 
    return "StringConstantCharArray:" + constant;
  }

<<<<<<< HEAD
=======
  @Override
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
  public Iterator> getCreationSites(CallGraph CG) {
    return EmptyIterator.instance();
  }
Solution content 
    return "StringConstantCharArray:" + constant;
  }

  @Override
  public Iterator> getCreationSites(CallGraph CG) {
    return EmptyIterator.instance();
  }
File
StringConstantCharArray.java
Developer's decision
Version 2
Kind of conflict
Annotation
Chunk
Conflicting content 
    return CallGraphTransitiveClosure.collectNodeResults(cg, new Function>() {

<<<<<<< HEAD
=======
      @Override
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
      public Collection apply(CGNode n) {
        return scanNodeForMod(n, pa, heapExclude);
      }
Solution content 
    return CallGraphTransitiveClosure.collectNodeResults(cg, new Function>() {

      @Override
      public Collection apply(CGNode n) {
        return scanNodeForMod(n, pa, heapExclude);
      }
File
ModRef.java
Developer's decision
Version 2
Kind of conflict
Annotation
Chunk
Conflicting content 
      public Collection apply(CGNode n) {
  private Map> scanForRef(CallGraph cg, final PointerAnalysis pa, final HeapExclusions heapExclude) {
    return CallGraphTransitiveClosure.collectNodeResults(cg, new Function>() {

<<<<<<< HEAD
=======
      @Override
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
        return scanNodeForRef(n, pa, heapExclude);
      }
Solution content 
  private Map> scanForRef(CallGraph cg, final PointerAnalysis pa, final HeapExclusions heapExclude) {
    return CallGraphTransitiveClosure.collectNodeResults(cg, new Function>() {

      @Override
      public Collection apply(CGNode n) {
        return scanNodeForRef(n, pa, heapExclude);
      }
File
ModRef.java
Developer's decision
Version 2
Kind of conflict
Annotation
Chunk
Conflicting content 
      String line;
      // assume the scope file is UTF-8 encoded; ASCII files will also be handled properly
      // TODO allow specifying encoding as a parameter?
<<<<<<< HEAD
/** BEGIN Custom change: try to load from jar as fallback */
      if (scopeFile.exists()) {
        r = new BufferedReader(new InputStreamReader(new FileInputStream(scopeFile), "UTF-8"));
      } else {
        // try to read from jar
        InputStream inFromJar = scope.getClass().getClassLoader().getResourceAsStream(scopeFileName);
        r = new BufferedReader(new InputStreamReader(inFromJar));
      }
/** END Custom change: try to load from jar as fallback */
=======
      r = new BufferedReader(new InputStreamReader(scopeFileInputStream, "UTF-8"));
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
      while ((line = r.readLine()) != null) {
        processScopeDefLine(scope, javaLoader, line);
      }
Solution content 
      String line;
      // assume the scope file is UTF-8 encoded; ASCII files will also be handled properly
      // TODO allow specifying encoding as a parameter?
/** BEGIN Custom change: try to load from jar as fallback */
      if (scopeFile.exists()) {
        r = new BufferedReader(new InputStreamReader(new FileInputStream(scopeFile), "UTF-8"));
      } else {
        // try to read from jar
        InputStream inFromJar = scope.getClass().getClassLoader().getResourceAsStream(scopeFileName);
        r = new BufferedReader(new InputStreamReader(inFromJar));
      }
/** END Custom change: try to load from jar as fallback */
      while ((line = r.readLine()) != null) {
        processScopeDefLine(scope, javaLoader, line);
      }
File
AnalysisScopeReader.java
Developer's decision
Version 1
Kind of conflict
Comment
If statement
Method invocation
Variable
Chunk
Conflicting content 
import java.net.JarURLConnection;
import java.net.URI;
import java.net.URL;
<<<<<<< HEAD
import java.net.URLConnection;
=======
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
import java.net.URLDecoder;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
Solution content 
import java.net.JarURLConnection;
import java.net.URI;
import java.net.URL;
import java.net.URLConnection;
import java.net.URLDecoder;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
File
FileProvider.java
Developer's decision
Version 1
Kind of conflict
Import
Chunk
Conflicting content 
import com.ibm.wala.classLoader.JarStreamModule;
import com.ibm.wala.classLoader.Module;
import com.ibm.wala.classLoader.NestedJarFileModule;
<<<<<<< HEAD
=======
import com.ibm.wala.classLoader.ResourceJarFileModule;
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
import com.ibm.wala.util.debug.Assertions;

/**
Solution content 
import com.ibm.wala.classLoader.JarStreamModule;
import com.ibm.wala.classLoader.Module;
import com.ibm.wala.classLoader.NestedJarFileModule;
import com.ibm.wala.classLoader.ResourceJarFileModule;
import com.ibm.wala.util.debug.Assertions;

/**
File
FileProvider.java
Developer's decision
Version 2
Kind of conflict
Import
Chunk
Conflicting content 
      JarEntry entry = jc.getJarEntry();
      JarFileModule parent = new JarFileModule(f);
      return new NestedJarFileModule(parent, entry);
<<<<<<< HEAD
/** BEGIN Custom change: try to load from input stream as fallback */
    } else if (url.getProtocol().equals("file")) {
=======
    } else if (url.getProtocol().equals("rsrc")) {
      return new ResourceJarFileModule(url);
    } else {
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
      String filePath = filePathFromURL(url);
      return new JarFileModule(new JarFile(filePath, false));
    } else {
Solution content 
      JarEntry entry = jc.getJarEntry();
      JarFileModule parent = new JarFileModule(f);
      return new NestedJarFileModule(parent, entry);
    } else if (url.getProtocol().equals("rsrc")) {
      return new ResourceJarFileModule(url);
/** BEGIN Custom change: try to load from input stream as fallback */
    } else if (url.getProtocol().equals("file")) {
      String filePath = filePathFromURL(url);
      return new JarFileModule(new JarFile(filePath, false));
    } else {
File
FileProvider.java
Developer's decision
Combination
Kind of conflict
Comment
If statement
Method invocation
Return statement
Chunk
Conflicting content 
	}


<<<<<<< HEAD
	public int getKind() {
=======
	@Override
  public int getKind() {
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
      return TYPE_ENTITY;
    }
Solution content 
	}


	@Override
  public int getKind() {
      return TYPE_ENTITY;
    }
File
JDTJava2CAstTranslator.java
Developer's decision
Version 2
Kind of conflict
Annotation
Method signature
Chunk
Conflicting content 
		return annotations;
	}

<<<<<<< HEAD
	public String toString() {
=======
	@Override
  public String toString() {
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
      return fDecl == null ? "" : fDecl.toString();
    }
Solution content 
		return annotations;
	}

	@Override
  public String toString() {
      return fDecl == null ? "" : fDecl.toString();
    }
File
JDTJava2CAstTranslator.java
Developer's decision
Version 2
Kind of conflict
Annotation
Method signature
Chunk
Conflicting content 
		return annotations;
	}

<<<<<<< HEAD
	public int getKind() {
=======
	@Override
  public int getKind() {
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
      return CAstEntity.FIELD_ENTITY;
    }
Solution content 
		return annotations;
	}

	@Override
  public int getKind() {
      return CAstEntity.FIELD_ENTITY;
    }
File
JDTJava2CAstTranslator.java
Developer's decision
Version 2
Kind of conflict
Annotation
Method signature
Chunk
Conflicting content 
		return null;
	}

<<<<<<< HEAD
	public int getKind() {
=======
	@Override
  public int getKind() {
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
      return FILE_ENTITY;
    }
Solution content 
		return null;
	}

	@Override
  public int getKind() {
      return FILE_ENTITY;
    }
File
JDTJava2CAstTranslator.java
Developer's decision
Version 2
Kind of conflict
Annotation
Method signature
Chunk
Conflicting content 
    killNanny();
  }

<<<<<<< HEAD
/** BEGIN Custom change: subtasks and canceling */
  @Override
  public void subTask(String subTask) {
    delegate.subTask(subTask);
  }

  @Override
  public void cancel() {
    setCanceled(true);
  }

/** END Custom change: subtasks and canceling */
=======
  @Override
>>>>>>> b984760100e3be325d458f61b0d556f479701c95
  public synchronized void worked(int work) {
    killNanny();
    delegate.worked(work);
Solution content 
    killNanny();
  }

/** BEGIN Custom change: subtasks and canceling */
  @Override
  public void subTask(String subTask) {
    delegate.subTask(subTask);
  }

  @Override
  public void cancel() {
    setCanceled(true);
  }

/** END Custom change: subtasks and canceling */
  @Override
  public synchronized void worked(int work) {
    killNanny();
    delegate.worked(work);
File
ProgressMaster.java
Developer's decision
Concatenation
Kind of conflict
Annotation
Comment
Method declaration