fix autocomplete and renaming behavior for same var and func name

client/modules/IDE/components/contextAwareHinter.js

@@ -96,14 +96,14 @@ export default function contextAwareHinter(cm, options = {}) {
   function isInScope(varName) {
     return Object.entries(scopeToDeclaredVarsMap).some(
       ([scope, vars]) =>
-        vars.has(varName) && (scope === 'global' || scope === currentContext)
+        varName in vars && (scope === 'global' || scope === currentContext)
     );
   }
 
   const allVarNames = Array.from(
     new Set(
       Object.values(scopeToDeclaredVarsMap)
-        .map((s) => Array.from(s))
+        .map((s) => Object.keys(s))
         .flat()
         .filter((name) => typeof name === 'string')
     )
@@ -115,7 +115,11 @@ export default function contextAwareHinter(cm, options = {}) {
         varName.toLowerCase().startsWith(lowerCurrentWord) && isInScope(varName)
     )
     .map((varName) => {
-      const isFunc = !!userDefinedFunctionMetadata[varName];
+      const isFunc = Object.entries(scopeToDeclaredVarsMap).some(
+        ([s, vars]) =>
+          (s === 'global' || s === currentContext) && vars[varName] === 'fun'
+      );
+
       const baseItem = isFunc
         ? { ...userDefinedFunctionMetadata[varName] }
         : {

client/modules/IDE/components/jump-to-definition.js

@@ -8,22 +8,25 @@ export function jumpToDefinition(pos) {
   const token = cm.getTokenAt(pos);
   const tokenType = token.type;
 
-  if (!tokenType || !tokenType.includes('variable')) return;
+  if (!tokenType || !['variable', 'def'].some((t) => tokenType.includes(t)))
+    return;
 
   const varName = token.string;
 
   const ast = getAST(cm);
-  const scopeToDeclaredVarsMap =
-    p5CodeAstAnalyzer(cm).scopeToDeclaredVarsMap || {};
+  const { scopeToDeclaredVarsMap = {}, userDefinedFunctionMetadata = {} } =
+    p5CodeAstAnalyzer(cm) || {};
+
   const context = getContext(cm, ast, pos, scopeToDeclaredVarsMap);
 
-  if (
-    !context ||
-    !scopeToDeclaredVarsMap[context] ||
-    !scopeToDeclaredVarsMap[context].has(varName)
-  ) {
-    return;
-  }
+  // If not found in scope and not a user-defined function, abort
+  const isUserFunction = !!userDefinedFunctionMetadata[varName];
+  const isDeclaredVar =
+    context &&
+    scopeToDeclaredVarsMap[context] &&
+    varName in scopeToDeclaredVarsMap[context];
+
+  if (!isDeclaredVar && !isUserFunction) return;
 
   const targetIndex = cm.indexFromPos(pos);
   let found = false;
@@ -53,8 +56,14 @@ export function jumpToDefinition(pos) {
       if (found) return;
 
       const { node } = path;
-      if (!node.params || !node.loc) return;
+      if (node.id?.type === 'Identifier' && node.id.name === varName) {
+        const defPos = cm.posFromIndex(node.start);
+        found = true;
+        cm.setCursor(defPos);
+        cm.focus();
+      }
 
+      if (!node.params || !node.loc) return;
       for (const param of node.params) {
         if (
           param.type === 'Identifier' &&

client/modules/IDE/components/p5CodeAstAnalyzer.js

@@ -63,10 +63,10 @@ function _p5CodeAstAnalyzer(_cm) {
           (def.type === 'FunctionName' && !allFunsList.has(def.name.name))
         ) {
           if (!scopeToDeclaredVarsMap[scopeName]) {
-            scopeToDeclaredVarsMap[scopeName] = new Set();
+            scopeToDeclaredVarsMap[scopeName] = {};
           }
-
-          scopeToDeclaredVarsMap[scopeName].add(def.name.name);
+          const defType = def.type === 'FunctionName' ? 'fun' : 'var';
+          scopeToDeclaredVarsMap[scopeName][def.name.name] = defType;
         }
       });
     });
@@ -190,13 +190,12 @@ function _p5CodeAstAnalyzer(_cm) {
             params
           };
 
-          // Store function params in the scopeToDeclaredVarsMap
           if (!scopeToDeclaredVarsMap[fnName]) {
-            scopeToDeclaredVarsMap[fnName] = new Set();
+            scopeToDeclaredVarsMap[fnName] = {};
           }
           params.forEach((paramObj) => {
             if (paramObj && paramObj.p) {
-              scopeToDeclaredVarsMap[fnName].add(paramObj.p);
+              scopeToDeclaredVarsMap[fnName][paramObj.p] = 'param';
             }
           });
         }

client/modules/IDE/components/rename-variable.js

@@ -19,9 +19,9 @@ export function handleRename(fromPos, oldName, newName, cm) {
   }
   const ast = getAST(cm);
   const context = getContext(cm, ast, fromPos, scopeToDeclaredVarsMap);
+  // const state = getRenameSearchState(cm, oldName);
+  // const matches = getMatches(cm, state, state.query);
   startRenaming(cm, ast, fromPos, newName, oldName);
-  const state = getRenameSearchState(cm, oldName);
-  const matches = getMatches(cm, state, state.query);
 }
 
 export function getContext(cm, ast, fromPos, scopeToDeclaredVarsMap) {
@@ -66,7 +66,7 @@ export function getContext(cm, ast, fromPos, scopeToDeclaredVarsMap) {
   const varName = foundNode.name;
 
   const contextCandidates = Object.entries(scopeToDeclaredVarsMap)
-    .filter(([context, vars]) => vars.has(varName))
+    .filter(([context, vars]) => varName in vars)
     .map(([context]) => context);
 
   if (contextCandidates.includes(enclosingFunction)) {
@@ -161,6 +161,7 @@ function getMatches(cm, state, query) {
     );
   }
   var matches = cm.state.search.annotate.matches;
+  console.log('match=', cm.state.search);
   return matches;
 }