docs: function findImplRecurse(offset, serverFile, candidateImpl, server){
  			var query, typeDef, newServerFile;
  			if (serverFile) {
  				var node = Finder.findNode(offset, serverFile.ast, {parents: true});
  				if (node){
  					if (node.type === 'Identifier') {
  						var parent = node.parents[node.parents.length-1];
  						if (parent){
  							if (parent.type === 'MemberExpression' && node.parents.length >= 2) {
  								// See if the member expression is an assignment a.b=1 that we can follow, otherwise fallthrough and lookup typeDef for the property node
  								parent = node.parents[node.parents.length-2];
  							}
  							
  							var rhs;
  							if (parent.type === 'VariableDeclarator' && parent.init){
  								rhs = parent.init;
  							} else if (parent.type === 'AssignmentExpression' && parent.right){
  								rhs = parent.right;
  							} else if (parent.type === 'Property' && parent.value){
  								rhs = parent.value;
  							}
  							if (rhs){
  								if (rhs.type === 'Literal' || rhs.type === 'FunctionExpression') {
  									// Literals count as implementations
  									// Function expressions are implementations of a function
  									// Short circuit and use the current node
  									return {implementation: {start: node.start, end: node.end, file: serverFile.name}};
  								}
  								// Find the implementation of the RHS identifier
  								query = {start: rhs.start, end: rhs.end, file: serverFile.name, guess: true};
  								typeDef = tern.findDef(server, query, serverFile);
  								if (typeDef && typeof typeDef.start === 'number' && typeof typeDef.end === 'number' && (typeDef.start !== node.start || typeDef.end !== node.end)){
  									newServerFile = server.fileMap[typeDef.file];
  									return this.findImplRecurse(typeDef.end, newServerFile, {implementation: {start: typeDef.start, end: typeDef.end, file: typeDef.file}}, server);
  								}
  							}
  						}
  						// There are many parents of an identifier, rather than list them all, default to look up the typeDef of the identifier
  						query = {start: node.start, end: node.end, file: serverFile.name, guess: true};
  						typeDef = tern.findDef(server, query, serverFile);
  						if (typeDef){
  							if (typeof typeDef.start === 'number' && typeof typeDef.end === 'number'){
  								if (typeDef.start !== node.start || typeDef.end !== node.end){
  									// Found a new node, recurse into the declaring node
  									newServerFile = server.fileMap[typeDef.file];
  									return this.findImplRecurse(typeDef.end, newServerFile, {implementation: {start: typeDef.start, end: typeDef.end, file: typeDef.file}}, server);
  								}
  							} else if (typeof typeDef.origin === 'string'){
  								// The declaration is in an index file
  								return {implementation: {origin: typeDef.origin}};
  							} else if (!candidateImpl.implementation){
  								// Could not find an implementation, still at the node we started at, tell the user we can't find an implementation	
  								return {};
  							}
  						}
  						
  						// The typeDef couldn't be found or matches the current node, just return the node
  						return {implementation: {start: node.start, end: node.end, file: serverFile.name}};
  					}
  				}
  			}
  			// Fall back on the last candidate implementation
  			return candidateImpl;
  		}