1 | "use strict";
|
2 |
|
3 | Object.defineProperty(exports, "__esModule", {
|
4 | value: true
|
5 | });
|
6 | exports.Logger = void 0;
|
7 |
|
8 | var _realm = require("../realm.js");
|
9 |
|
10 | var _errors = require("../errors.js");
|
11 |
|
12 | var _index = require("../methods/index.js");
|
13 |
|
14 | var _completions = require("../completions.js");
|
15 |
|
16 | var _index2 = require("../values/index.js");
|
17 |
|
18 | var _singletons = require("../singletons.js");
|
19 |
|
20 | var _invariant = _interopRequireDefault(require("../invariant.js"));
|
21 |
|
22 | function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
23 |
|
24 |
|
25 |
|
26 |
|
27 |
|
28 |
|
29 |
|
30 |
|
31 |
|
32 | class Logger {
|
33 | constructor(realm, internalDebug) {
|
34 | this.realm = realm;
|
35 | this._hasErrors = false;
|
36 | this.internalDebug = internalDebug;
|
37 | }
|
38 |
|
39 |
|
40 | tryQuery(f, defaultValue) {
|
41 | let realm = this.realm;
|
42 | let context = new _realm.ExecutionContext();
|
43 | context.isStrict = realm.isStrict;
|
44 | let env = realm.$GlobalEnv;
|
45 | context.lexicalEnvironment = env;
|
46 | context.variableEnvironment = env;
|
47 | context.realm = realm;
|
48 | realm.pushContext(context);
|
49 |
|
50 | let oldErrorHandler = realm.errorHandler;
|
51 |
|
52 | realm.errorHandler = d => {
|
53 | if (d.severity === "Information" || d.severity === "Warning") return "Recover";
|
54 | return "Fail";
|
55 | };
|
56 |
|
57 | try {
|
58 | let result;
|
59 | let effects = realm.evaluateForEffects(() => {
|
60 | try {
|
61 | result = f();
|
62 | } catch (e) {
|
63 | if (e instanceof _completions.Completion) {
|
64 | result = defaultValue;
|
65 | } else if (e instanceof _errors.FatalError) {
|
66 | result = defaultValue;
|
67 | } else {
|
68 | throw e;
|
69 | }
|
70 | }
|
71 |
|
72 | return realm.intrinsics.undefined;
|
73 | }, undefined, "tryQuery");
|
74 | (0, _invariant.default)(effects.result.value === realm.intrinsics.undefined);
|
75 | return result;
|
76 | } finally {
|
77 | realm.errorHandler = oldErrorHandler;
|
78 | realm.popContext(context);
|
79 | }
|
80 | }
|
81 |
|
82 | logCompletion(res) {
|
83 | let realm = this.realm;
|
84 | let value = res.value;
|
85 | if (this.internalDebug) console.error(`=== ${res.constructor.name} ===`);
|
86 |
|
87 | if (this.tryQuery(() => value instanceof _index2.ObjectValue && (0, _index.InstanceofOperator)(realm, value, realm.intrinsics.Error), false)) {
|
88 | let object = value;
|
89 |
|
90 | try {
|
91 | let err = new _errors.FatalError(this.tryQuery(() => _singletons.To.ToStringPartial(realm, (0, _index.Get)(realm, object, "message")), "(unknown message)"));
|
92 | err.stack = this.tryQuery(() => _singletons.To.ToStringPartial(realm, (0, _index.Get)(realm, object, "stack")), "(unknown stack)");
|
93 | console.error(err.message);
|
94 | console.error(err.stack);
|
95 | if (this.internalDebug && res instanceof _completions.ThrowCompletion) console.error(res.nativeStack);
|
96 | } catch (err) {
|
97 | let message = object.properties.get("message");
|
98 | console.error(message && message.descriptor && message.descriptor.value instanceof _index2.StringValue ? message.descriptor.value.value : "(no message available)");
|
99 | console.error(err.stack);
|
100 |
|
101 | if (object.$ErrorData) {
|
102 | console.error(object.$ErrorData.contextStack);
|
103 | }
|
104 | }
|
105 | } else {
|
106 | try {
|
107 | value = _singletons.To.ToStringPartial(realm, value);
|
108 | } catch (err) {
|
109 | value = err.message;
|
110 | }
|
111 |
|
112 | console.error(value);
|
113 | if (this.internalDebug && res instanceof _completions.ThrowCompletion) console.error(res.nativeStack);
|
114 | }
|
115 |
|
116 | this._hasErrors = true;
|
117 | }
|
118 |
|
119 | logError(value, message) {
|
120 | this._log(value, message, "RecoverableError");
|
121 |
|
122 | this._hasErrors = true;
|
123 | }
|
124 |
|
125 | logWarning(value, message) {
|
126 | this._log(value, message, "Warning");
|
127 | }
|
128 |
|
129 | logInformation(message) {
|
130 | this._log(this.realm.intrinsics.undefined, message, "Information");
|
131 | }
|
132 |
|
133 | _log(value, message, severity) {
|
134 | let loc = value.expressionLocation;
|
135 |
|
136 | if (value.intrinsicName) {
|
137 | message = `${message}\nintrinsic name: ${value.intrinsicName}`;
|
138 | }
|
139 |
|
140 | let diagnostic = new _errors.CompilerDiagnostic(message, loc, "PP9000", severity);
|
141 | if (this.realm.handleError(diagnostic) === "Fail") throw new _errors.FatalError();
|
142 | }
|
143 |
|
144 | hasErrors() {
|
145 | return this._hasErrors;
|
146 | }
|
147 |
|
148 | }
|
149 |
|
150 | exports.Logger = Logger;
|
151 |
|
\ | No newline at end of file |