Power Platform QA Solution

Metadata

IDdead-code

Result KeydeadCode

Filedead-code.js

Built-inYes

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

Finds write-only variables, stale control/screen references, unused named formulas, and unreachable screens

Prompt

Not available — this analyzer was not AI-generated.

Source Code

dead-code.js — read-only (built-in) · Input data reference ↗

Checking…

export default {
  name: 'Dead Code',
  description: 'Finds write-only variables, stale control/screen references, unused named formulas, and unreachable screens',
  resultKey: 'deadCode',
  resultSchema: {
    keys: [
      { key: 'type',      label: 'Type',      suggestedFormat: 'deadcode-type' },
      { key: 'name',      label: 'Name',      suggestedFormat: 'name-copy' },
      { key: 'message',   label: 'Details',   suggestedFormat: 'text-sm' },
      { key: 'locations', label: 'Locations', suggestedFormat: 'locations' }
    ]
  },
  analyze(controlTree, refGraph, extraction) {
    return findDeadCode(controlTree, refGraph, extraction);
  }
};

export function findDeadCode(controlTree, refGraph, extraction) {
  const results = [];

  // Pass 1: Write-only variables
  findWriteOnlyVariables(extraction, refGraph, results);

  // Pass 2: Write-only collections
  findWriteOnlyCollections(extraction, refGraph, results);

  // Pass 3: Stale control references
  findStaleControlRefs(extraction, controlTree, results);

  // Pass 4: Stale screen references
  findStaleScreenRefs(extraction, controlTree, results);

  // Pass 5: Unused named formulas
  findUnusedNamedFormulas(extraction, refGraph, results);

  // Pass 6: Unreachable screens
  findUnreachableScreens(controlTree, refGraph, extraction, results);

  return results;
}

function findWriteOnlyVariables(extraction, refGraph, results) {
  for (const [varName, writeLocations] of extraction.variableWrites) {
    if (refGraph.variablesRead.has(varName)) continue;

    results.push({
      type: 'write-only-variable',
      name: varName,
      locations: writeLocations.map(loc => ({
        control: loc.control,
        property: loc.property,
        file: loc.file,
        snippet: loc.snippet,
      })),
      message: `Variable '${varName}' is set but never read anywhere in the app`,
    });
  }
}

function findWriteOnlyCollections(extraction, refGraph, results) {
  for (const [colName, writeLocations] of extraction.collectionWrites) {
    if (refGraph.collectionsRead.has(colName)) continue;

    results.push({
      type: 'write-only-collection',
      name: colName,
      locations: writeLocations.map(loc => ({
        control: loc.control,
        property: loc.property,
        file: loc.file,
        snippet: loc.snippet,
      })),
      message: `Collection '${colName}' is populated but never read anywhere in the app`,
    });
  }
}

function findStaleControlRefs(extraction, controlTree, results) {
  const allRefMaps = [extraction.selectRefs, extraction.resetRefs, extraction.dotAccessRefs];

  for (const refMap of allRefMaps) {
    for (const [controlName, locations] of refMap) {
      if (controlTree.nodeIndex.has(controlName)) continue;

      // This control is referenced but doesn't exist
      results.push({
        type: 'stale-control-reference',
        name: controlName,
        locations: locations.map(loc => ({
          control: loc.control,
          property: loc.property,
          file: loc.file,
          snippet: loc.snippet,
          refType: loc.refType || 'reference',
        })),
        message: `Control '${controlName}' is referenced but does not exist in the app`,
      });
    }
  }
}

function findStaleScreenRefs(extraction, controlTree, results) {
  const screenNames = new Set(controlTree.screens.map(s => s.name));

  for (const [screenName, locations] of extraction.navigateRefs) {
    if (screenNames.has(screenName)) continue;

    results.push({
      type: 'stale-screen-reference',
      name: screenName,
      locations: locations.map(loc => ({
        control: loc.control,
        property: loc.property,
        file: loc.file,
        snippet: loc.snippet,
      })),
      message: `Screen '${screenName}' is used in Navigate() but does not exist`,
    });
  }
}

function findUnusedNamedFormulas(extraction, refGraph, results) {
  for (const [formulaName, location] of extraction.namedFormulaDefs) {
    if (refGraph.namedFormulasRead.has(formulaName)) continue;

    results.push({
      type: 'unused-named-formula',
      name: formulaName,
      locations: [{
        control: location.control,
        property: location.property,
        file: location.file,
      }],
      message: `Named formula '${formulaName}' is defined in App.Formulas but never referenced`,
    });
  }
}

function findUnreachableScreens(controlTree, refGraph, extraction, results) {
  // Find the start screen
  let startScreenNames = new Set();
  if (controlTree.startScreenFormula) {
    // Parse screen names from StartScreen formula
    for (const screen of controlTree.screens) {
      if (controlTree.startScreenFormula.includes(screen.name)) {
        startScreenNames.add(screen.name);
      }
    }
  }
  // If no start screen found, assume first screen is the default
  if (startScreenNames.size === 0 && controlTree.screens.length > 0) {
    startScreenNames.add(controlTree.screens[0].name);
  }

  const navigatedScreens = new Set(extraction.navigateRefs.keys());
  // Also check for screen references in App.Formulas (Screen: Screen_Home patterns)
  const appFormulas = controlTree.appNode?.formulas.get('Formulas') || '';
  for (const screen of controlTree.screens) {
    if (appFormulas.includes(screen.name)) {
      navigatedScreens.add(screen.name);
    }
  }

  for (const screen of controlTree.screens) {
    if (startScreenNames.has(screen.name)) continue;
    if (navigatedScreens.has(screen.name)) continue;

    results.push({
      type: 'unreachable-screen',
      name: screen.name,
      locations: [{ file: screen.filePath }],
      message: `Screen '${screen.name}' is never targeted by Navigate() and is not the start screen`,
    });
  }
}

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 — Dead Code BUILT-IN

Test Dead Code

Test results