Power Platform QA Solution

Metadata

IDglobal-variables-where-context-variables-would-suffice

Result KeyunnecessaryGlobalVars

Fileglobal-variables-where-context-variables-would-suffice.js

Built-inNo

Analyzer Classification

Category — This determines the type of Analyzer you are building. Categories can be set up under settings.

Test sets — Include this analyzer in predefined runs. Select one or more test sets this analyzer should belong to.

Dataverse test set Some tests

Description

Prompt

Provider

Source Code

global-variables-where-context-variables-would-suffice.js · Input data reference ↗

Checking…

export default {
  name: "Set vs UpdateContext Usage",
  description: "Detects unnecessary use of Set() where UpdateContext() could be used instead for better performance and scoping",
  resultKey: "setVsUpdateContext",
  resultSchema: {
    keys: [
      { key: "name", label: "Variable", suggestedFormat: "text" },
      { key: "type", label: "Issue Type", suggestedFormat: "badge-info" },
      { key: "message", label: "Description", suggestedFormat: "text" },
      { key: "locations", label: "Locations", suggestedFormat: "locations" },
      { key: "confidence", label: "Confidence", suggestedFormat: "badge-confidence" }
    ]
  },
  
  analyze(controlTree, refGraph, extraction) {
    const results = [];
    const globalVarUsage = new Map();
    const contextVarUsage = new Map();
    
    // First pass: collect all Set() and UpdateContext() calls
    extraction.allFormulas.forEach(({ control, property, formula, file }) => {
      // Find Set() calls
      const setMatches = formula.matchAll(/\bSet\s*\(\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*,/g);
      for (const match of setMatches) {
        const varName = match[1];
        if (!globalVarUsage.has(varName)) {
          globalVarUsage.set(varName, []);
        }
        globalVarUsage.get(varName).push({
          control,
          property,
          file,
          snippet: match[0],
          formula
        });
      }
      
      // Find UpdateContext() calls
      const updateContextMatches = formula.matchAll(/\bUpdateContext\s*\(\s*\{[^}]*([a-zA-Z_][a-zA-Z0-9_]*)\s*:/g);
      for (const match of updateContextMatches) {
        const varName = match[1];
        if (!contextVarUsage.has(varName)) {
          contextVarUsage.set(varName, []);
        }
        contextVarUsage.get(varName).push({
          control,
          property,
          file,
          snippet: match[0],
          formula
        });
      }
    });
    
    // Analyze each global variable for potential UpdateContext usage
    globalVarUsage.forEach((locations, varName) => {
      // Skip if variable is also used with UpdateContext (mixed usage)
      if (contextVarUsage.has(varName)) {
        return;
      }
      
      let shouldUseUpdateContext = true;
      let confidence = 'high';
      let reason = '';
      
      // Check if variable is used across different screens
      const screensUsed = new Set();
      let usedInAppLevel = false;
      
      locations.forEach(location => {
        const node = controlTree.nodeIndex.get(location.control);
        if (node?.isApp) {
          usedInAppLevel = true;
        } else if (node?.screen) {
          screensUsed.add(node.screen);
        }
      });
      
      // Check if variable is referenced across different screens
      const refLocations = refGraph.referencedControls.get(varName) || [];
      refLocations.forEach(ref => {
        const node = controlTree.nodeIndex.get(ref.control);
        if (node?.screen) {
          screensUsed.add(node.screen);
        }
      });
      
      // If used in App-level formulas or across multiple screens, Set() might be appropriate
      if (usedInAppLevel) {
        shouldUseUpdateContext = false;
        reason = 'Variable is used in App-level formulas';
      } else if (screensUsed.size > 1) {
        shouldUseUpdateContext = false;
        reason = 'Variable is used across multiple screens';
      } else if (screensUsed.size === 0) {
        // Variable might be in a component - check component usage
        const componentUsage = new Set();
        locations.forEach(location => {
          const node = controlTree.nodeIndex.get(location.control);
          if (node?.componentName) {
            componentUsage.add(node.componentName);
          }
        });
        
        if (componentUsage.size > 0) {
          shouldUseUpdateContext = false;
          reason = 'Variable is used in component definitions';
        }
      }
      
      // Additional checks for Set() usage patterns
      locations.forEach(location => {
        const formula = location.formula;
        
        // Check if Set() is used in OnStart (global initialization)
        if (location.property === 'OnStart') {
          shouldUseUpdateContext = false;
          reason = 'Variable is initialized in OnStart';
        }
        
        // Check for complex Set() patterns that might indicate global state
        if (formula.includes('Navigate(') || formula.includes('Back(')) {
          confidence = 'medium';
        }
        
        // Check if Set() is used with other global functions
        if (formula.includes('Concurrent(') || formula.includes('ClearCollect(')) {
          confidence = 'medium';
        }
      });
      
      if (shouldUseUpdateContext) {
        let message = `Variable '${varName}' is set using Set() but could use UpdateContext() instead for better performance and local scoping`;
        
        if (screensUsed.size === 1) {
          message += ` (only used within ${Array.from(screensUsed)[0]})`;
        } else if (screensUsed.size === 0) {
          message += ` (appears to be locally scoped)`;
        }
        
        // Check for multiple Set() calls that could be combined into one UpdateContext()
        if (locations.length > 1) {
          const sameControl = locations.filter(loc => loc.control === locations[0].control && loc.property === locations[0].property);
          if (sameControl.length > 1) {
            message += `. Consider combining multiple Set() calls into a single UpdateContext() call`;
          }
        }
        
        results.push({
          name: varName,
          type: "unnecessary-set",
          message,
          locations: locations.map(loc => ({
            control: loc.control,
            property: loc.property,
            file: loc.file,
            snippet: loc.snippet
          })),
          confidence
        });
      } else if (reason) {
        // This is appropriate use of Set(), but still report for awareness
        results.push({
          name: varName,
          type: "appropriate-set",
          message: `Set() usage is appropriate for '${varName}': ${reason}`,
          locations: locations.map(loc => ({
            control: loc.control,
            property: loc.property,
            file: loc.file,
            snippet: loc.snippet
          })),
          confidence: 'high'
        });
      }
    });
    
    // Look for potential UpdateContext() optimizations
    contextVarUsage.forEach((locations, varName) => {
      // Check if UpdateContext() is called multiple times for the same variable in the same context
      const locationGroups = new Map();
      
      locations.forEach(location => {
        const key = `${location.control}-${location.property}`;
        if (!locationGroups.has(key)) {
          locationGroups.set(key, []);
        }
        locationGroups.get(key).push(location);
      });
      
      locationGroups.forEach((group, key) => {
        if (group.length > 1) {
          results.push({
            name: varName,
            type: "multiple-updatecontext",
            message: `Variable '${varName}' is updated multiple times with UpdateContext() in the same property. Consider combining into a single call`,
            locations: group.map(loc => ({
              control: loc.control,
              property: loc.property,
              file: loc.file,
              snippet: loc.snippet
            })),
            confidence: 'medium'
          });
        }
      });
    });
    
    return results;
  }
};

Report Output Columns

Columns shown in the generated report. Toggle off to hide; pick a declared key or use "Custom…" for dot-paths like locations.0.file.

Enabled	Key	Label	Format	Width

Configure Analyzer — Global Variables Where Context Variables Would Suffice CUSTOM

Test Global Variables Where Context Variables Would Suffice

Test results