Update ppa type definitions (#11067)

* Update ppa type definitions

Author: greazer

types/@msrvida-python-program-analysis/cellslice.d.ts

@@ -1,27 +1,20 @@
 import { Cell } from './cell';
 import { LocationSet } from './slice';
 export declare class CellSlice {
+    readonly cell: Cell;
+    slice: LocationSet;
+    readonly executionTime?: Date;
     /**
      * Construct an instance of a cell slice.
      */
     constructor(cell: Cell, slice: LocationSet, executionTime?: Date);
     /**
      * Get the text in the slice of a cell.
      */
-    readonly textSlice: string;
+    get textSlice(): string;
     /**
      * Get the text of all lines in a slice (no deletions from lines).
      */
-    readonly textSliceLines: string;
+    get textSliceLines(): string;
     private getTextSlice;
-    /**
-     * Get the slice.
-     */
-    /**
-    * Set the slice.
-    */
-    slice: LocationSet;
-    readonly cell: Cell;
-    readonly executionTime: Date;
-    private _slice;
 }

types/@msrvida-python-program-analysis/control-flow.d.ts

@@ -3,9 +3,12 @@ export declare class Block {
     id: number;
     readonly hint: string;
     statements: ast.SyntaxNode[];
+    private imports;
     loopVariables: ast.SyntaxNode[];
-    constructor(id: number, hint: string, statements: ast.SyntaxNode[], loopVariables?: ast.SyntaxNode[]);
+    private ssa;
+    constructor(id: number, hint: string, statements: ast.SyntaxNode[], imports: string[], loopVariables?: ast.SyntaxNode[]);
     toString(): string;
+    get flattenedStatements(): ast.SyntaxNode[];
 }
 export declare class ControlFlowGraph {
     private _blocks;
@@ -14,9 +17,10 @@ export declare class ControlFlowGraph {
     private exit;
     private successors;
     private loopVariables;
+    private imports;
     constructor(node: ast.SyntaxNode);
     private makeBlock;
-    readonly blocks: Block[];
+    get blocks(): Block[];
     getSuccessors(block: Block): Block[];
     getPredecessors(block: Block): Block[];
     print(): void;

types/@msrvida-python-program-analysis/data-flow.d.ts

@@ -1,29 +1,61 @@
 import * as ast from './python-parser';
 import { ControlFlowGraph } from './control-flow';
 import { Set } from './set';
-import { JsonSpecs, PythonType } from './specs';
-declare class DefUse {
+import { Spec } from './specs';
+import { SymbolTable } from './symbol-table';
+export interface Dataflow {
+    fromNode: ast.SyntaxNode;
+    toNode: ast.SyntaxNode;
+    fromRef?: Ref;
+    toRef?: Ref;
+}
+export declare enum ReferenceType {
+    DEFINITION = "DEFINITION",
+    UPDATE = "UPDATE",
+    USE = "USE"
+}
+export interface Ref {
+    level: ReferenceType;
+    name: string;
+    location: ast.Location;
+    node: ast.SyntaxNode;
+}
+export declare class RefSet extends Set<Ref> {
+    constructor(...items: Ref[]);
+}
+declare class DefUseDelta {
     DEFINITION: RefSet;
     UPDATE: RefSet;
     USE: RefSet;
-    constructor(DEFINITION?: RefSet, UPDATE?: RefSet, USE?: RefSet);
-    readonly defs: Set<Ref>;
-    readonly uses: Set<Ref>;
+    leaks: LeakInfo[];
+    constructor(DEFINITION?: RefSet, UPDATE?: RefSet, USE?: RefSet, leaks?: LeakInfo[]);
+    get uses(): Set<Ref>;
+    createFlowsFrom(fromSet: DefUse): [Set<Dataflow>, Set<Ref>];
+}
+declare class DefUse {
+    private DEFINITION;
+    private UPDATE;
+    private USE;
+    leaks: LeakInfo[];
+    constructor(DEFINITION?: RefSet, UPDATE?: RefSet, USE?: RefSet, leaks?: LeakInfo[]);
+    get defs(): Set<Ref>;
     union(that: DefUse): DefUse;
-    update(newRefs: DefUse): void;
+    update(newRefs: DefUseDelta): void;
     equals(that: DefUse): boolean;
-    createFlowsFrom(fromSet: DefUse): [Set<Dataflow>, Set<Ref>];
 }
 /**
  * Use a shared dataflow analyzer object for all dataflow analysis / querying for defs and uses.
  * It caches defs and uses for each statement, which can save time.
  * For caching to work, statements must be annotated with a cell's ID and execution count.
  */
 export declare class DataflowAnalyzer {
-    constructor(moduleMap?: JsonSpecs);
-    getDefUseForStatement(statement: ast.SyntaxNode, defsForMethodResolution: RefSet): DefUse;
+    constructor(moduleMap?: Spec, symbolTable?: SymbolTable);
+    getDefUseForStatement(statement: ast.SyntaxNode, incomingDefs: RefSet, incomingLeaks: LeakInfo[]): DefUseDelta;
     analyze(cfg: ControlFlowGraph, refSet?: RefSet): DataflowAnalysisResult;
-    getDefs(statement: ast.SyntaxNode, defsForMethodResolution: RefSet): RefSet;
+    getDefs(statement: ast.SyntaxNode, stateLeaks: LeakInfo[]): {
+        defs: RefSet;
+        leaks: LeakInfo[];
+    };
     private getClassDefs;
     private getFuncDefs;
     private getAssignDefs;
@@ -35,41 +67,15 @@ export declare class DataflowAnalyzer {
     private getClassDeclUses;
     private getFuncDeclUses;
     private getAssignUses;
-    private _symbolTable;
+    private symbolTable;
     private _defUsesCache;
 }
-export interface Dataflow {
-    fromNode: ast.SyntaxNode;
-    toNode: ast.SyntaxNode;
-    fromRef?: Ref;
-    toRef?: Ref;
-}
-export declare enum ReferenceType {
-    DEFINITION = "DEFINITION",
-    UPDATE = "UPDATE",
-    USE = "USE"
-}
-export declare enum SymbolType {
-    VARIABLE = 0,
-    CLASS = 1,
-    FUNCTION = 2,
-    IMPORT = 3,
-    MUTATION = 4,
-    MAGIC = 5
-}
-export interface Ref {
-    type: SymbolType;
-    level: ReferenceType;
-    name: string;
-    inferredType?: PythonType;
-    location: ast.Location;
-    node: ast.SyntaxNode;
-}
-export declare class RefSet extends Set<Ref> {
-    constructor(...items: Ref[]);
-}
 export declare function sameLocation(loc1: ast.Location, loc2: ast.Location): boolean;
 export declare const GlobalSyntheticVariable = "$global";
+interface LeakInfo {
+    innerName: string;
+    outerName: string;
+}
 export declare type DataflowAnalysisResult = {
     dataflows: Set<Dataflow>;
     undefinedRefs: RefSet;

types/@msrvida-python-program-analysis/genspec/main.d.ts

@@ -5,6 +5,6 @@ export declare class Graph<T> {
     private _nodes;
     constructor(getIdentifier: (item: T) => string);
     addEdge(fromNode: T, toNode: T): void;
-    readonly nodes: T[];
+    get nodes(): T[];
     topoSort(): T[];
 }

types/@msrvida-python-program-analysis/genspec/moduleSpecWalker.d.ts

@@ -66,7 +66,7 @@ export declare class ExecutionLogSlicer<TCell extends Cell> {
      * Relevant line numbers are relative to the cell's start line (starting at first line = 0).
      */
     sliceAllExecutions(cellId: string, seedLocations?: LocationSet): SlicedExecution[];
-    readonly cellExecutions: ReadonlyArray<CellExecution<TCell>>;
+    get cellExecutions(): ReadonlyArray<CellExecution<TCell>>;
     /**
      * Get the cell program (tree, defs, uses) for a cell.
      */

types/@msrvida-python-program-analysis/graph.d.ts

@@ -1,2 +1,3 @@
 export declare function startLogging(): void;
+export declare function stopLogging(): void;
 export declare function log(message: string, ...args: any[]): void;

types/@msrvida-python-program-analysis/log-slicer.d.ts

@@ -41,7 +41,7 @@ export interface From extends Locatable {
     type: typeof FROM;
     base: string;
     imports: {
-        path: string;
+        name: string;
         alias: string;
         location: Location;
     }[];

types/@msrvida-python-program-analysis/logutil.d.ts

@@ -55,6 +55,7 @@ export declare class MagicsRewriter {
      * Rewrite code so that it doesn't contain magics.
      */
     rewrite(text: string, lineMagicRewriters?: LineMagicRewriter[]): string;
+    rewriteShellCommand(text: string): string;
     /**
      * Default rewrite rule for cell magics.
      */

types/@msrvida-python-program-analysis/python-parser.d.ts

@@ -2,14 +2,14 @@ export declare class Set<T> {
     private getIdentifier;
     private _items;
     constructor(getIdentifier: (item: T) => string, ...items: T[]);
-    readonly size: number;
+    get size(): number;
     add(...items: T[]): void;
     remove(item: T): void;
     pop(): T;
     has(item: T): boolean;
-    readonly items: T[];
+    get items(): T[];
     equals(that: Set<T>): boolean;
-    readonly empty: boolean;
+    get empty(): boolean;
     union(...those: Set<T>[]): Set<T>;
     intersect(that: Set<T>): Set<T>;
     filter(predicate: (item: T) => boolean): Set<T>;

types/@msrvida-python-program-analysis/rewrite-magics.d.ts

@@ -1,35 +1,14 @@
-export interface FunctionSpec {
-    name: string;
-    updates?: (string | number)[];
-    reads?: string[];
-    returns?: string;
-    returnsType?: PythonType;
-    higherorder?: number;
+export interface Spec {
+    [name: string]: any;
 }
-export declare type FunctionDescription = string | FunctionSpec;
-export declare function getFunctionName(fd: FunctionDescription): string;
-export declare function isFunctionSpec(fd: FunctionDescription): fd is FunctionSpec;
 export declare type PythonType = ListType | ClassType;
 export declare class ListType {
     elementType: PythonType;
     constructor(elementType: PythonType);
 }
 export declare class ClassType {
-    spec: TypeSpec<FunctionSpec>;
-    constructor(spec: TypeSpec<FunctionSpec>);
+    private spec;
+    constructor(spec: Spec);
+    lookupMethod(name: string): any;
 }
-export interface TypeSpec<FD> {
-    methods?: FD[];
-}
-export interface ModuleSpec<FD> extends TypeSpec<FD> {
-    functions?: FD[];
-    modules?: ModuleMap<FD>;
-    types?: {
-        [typeName: string]: TypeSpec<FD>;
-    };
-}
-export interface ModuleMap<FD> {
-    [moduleName: string]: ModuleSpec<FD>;
-}
-export declare type JsonSpecs = ModuleMap<FunctionDescription>;
-export declare const DefaultSpecs: JsonSpecs;
+export declare const DefaultSpecs: Spec;