FilesExpand file tree

 errorOnHiddenModuleImport

/

perfsys.ts

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

106 lines (82 loc) · 2.85 KB

 errorOnHiddenModuleImport

/

perfsys.ts

Copy path

Top

File metadata and controls

• Code
• Blame

106 lines (82 loc) · 2.85 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

/// <reference path="..\src\compiler\sys.ts"/>

module perftest {

interface IOLog {

resolvePath: ts.Map<string>;

fileNames: string[];

}

export interface IO {

getOut(): string;

getErr(): string;

}

export var readFile = sys.readFile;

var writeFile = sys.writeFile;

export var write = sys.write;

export var writeErr = sys.writeErr;

var resolvePath = sys.resolvePath;

export var getExecutingFilePath = sys.getExecutingFilePath;

export var getCurrentDirectory = sys.getCurrentDirectory;

var args = sys.args;

// augment sys so first ts.executeCommandLine call will be finish silently

sys.writeErr = (s: string) => { };

sys.args = []

export function restoreSys() {

sys.args = args;

sys.writeErr = writeErr;

}

export function hasLogIOFlag() {

return args.length > 2 && args[0] === "--logio";

}

export function getArgsWithoutLogIOFlag() {

return args.slice(2);

}

export function getArgsWithoutIOLogFile() {

return args.slice(1);

}

var resolvePathLog: ts.Map<string> = {};

export function interceptIO() {

sys.resolvePath = (s) => {

var result = resolvePath(s);

resolvePathLog[s] = result;

return result;

};

}

export function writeIOLog(fileNames: string[]) {

var path = args[1];

var log: IOLog = {

fileNames: fileNames,

resolvePath: resolvePathLog

};

writeFile(path, JSON.stringify(log));

}

export function prepare(): IO {

var log = <IOLog>JSON.parse(readFile(args[0]));

var files: ts.Map<string> = {};

log.fileNames.forEach(f => { files[f] = readFile(f); })

sys.createDirectory = (s: string) => { };

sys.directoryExists = (s: string) => true;

sys.fileExists = (s: string) => true;

var currentDirectory = sys.getCurrentDirectory();

sys.getCurrentDirectory = () => currentDirectory;

var executingFilePath = sys.getExecutingFilePath();

sys.getExecutingFilePath = () => executingFilePath;

sys.readFile = (s: string) => {

return files[s];

}

sys.resolvePath = (s: string) => {

var path = log.resolvePath[s];

if (!path) {

throw new Error("Unexpected path '" + s + "'");

}

return path

}

sys.writeFile = (path: string, data: string) => { };

var out: string = "";

var err: string = "";

sys.write = (s: string) => { out += s; };

sys.writeErr = (s: string) => { err += s; };

return {

getOut: () => out,

getErr: () => err

};

}

}