/// <summary>
/// Loads a new instance from the specified registry key.
/// </summary>
/// <param name="key">
/// The key to load settings from. If
/// null, all settings are assumed to be unspecified and the default
/// values are used.
/// </param>
/// <param name="defaults">
/// The default analysis limits if they're not available in the regkey.
/// </param>
public static AnalysisLimits LoadLimitsFromStorage(RegistryKey key, AnalysisLimits defaults)
{
return(new AnalysisLimits()
{
ReturnTypes = GetSetting(key, ReturnTypesId) ?? defaults.ReturnTypes,
InstanceMembers = GetSetting(key, InstanceMembersId) ?? defaults.InstanceMembers,
DictKeyTypes = GetSetting(key, DictKeyTypesId) ?? defaults.DictKeyTypes,
DictValueTypes = GetSetting(key, DictValueTypesId) ?? defaults.DictValueTypes,
IndexTypes = GetSetting(key, IndexTypesId) ?? defaults.IndexTypes,
AssignedTypes = GetSetting(key, AssignedTypesId) ?? defaults.AssignedTypes,
NestedModulesLimit = GetSetting(key, NestedModulesLimitId) ?? defaults.NestedModulesLimit
});
}
public JsAnalyzer(AnalysisLimits limits = null)
{
_modules = new ModuleTable();
_itemCache = new Dictionary <object, AnalysisValue>();
_builtinEntry = new ProjectEntry(this, String.Empty, null);
Limits = limits ?? new AnalysisLimits();
_queue = new Deque <AnalysisUnit>();
_nullInst = new NullValue(this);
_trueInst = new BooleanValue(true, this);
_falseInst = new BooleanValue(false, this);
_undefined = new UndefinedValue(this);
_emptyStringValue = GetConstant(String.Empty);
_zeroIntValue = GetConstant(0.0);
var globals = GlobalBuilder.MakeGlobal(this);
_globalObject = globals.GlobalObject;
_numberPrototype = globals.NumberPrototype;
_stringPrototype = globals.StringPrototype;
_booleanPrototype = globals.BooleanPrototype;
_functionPrototype = globals.FunctionPrototype;
_arrayFunction = globals.ArrayFunction;
_objectPrototype = globals.ObjectPrototype;
_requireFunc = globals.RequireFunction;
_arrayPrototype = globals.ArrayPrototype;
_objectGetOwnPropertyDescriptor = globals.ObjectGetOwnPropertyDescriptor;
_immutableObject = new ImmutableObjectValue(_builtinEntry);
var allJson = Path.Combine(
Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location),
"all.json"
);
if (File.Exists(allJson))
{
NodejsModuleBuilder.Build(allJson, this);
}
else
{
Debug.Fail("Could not find all.json");
}
}
public static JsAnalyzer Analyze(AnalysisLimits limits, Action parseCallback, params AnalysisFile[] files) {
Dictionary<string, IJsProjectEntry> entries = new Dictionary<string, IJsProjectEntry>();
var analyzer = new JsAnalyzer(limits);
foreach (var file in files) {
if (Path.GetFileName(file.Filename).Equals("package.json", StringComparison.OrdinalIgnoreCase)) {
analyzer.AddPackageJson(file.Filename, file.Content);
} else {
var projEntry = analyzer.AddModule(file.Filename);
entries[file.Filename] = projEntry;
}
}
foreach (var file in files) {
if (!Path.GetFileName(file.Filename).Equals("package.json", StringComparison.OrdinalIgnoreCase)) {
var source = Analysis.GetSourceUnit(file.Content);
Analysis.Prepare(
entries[file.Filename],
source
);
}
}
if (parseCallback != null) {
parseCallback();
}
foreach (var file in files) {
if (!Path.GetFileName(file.Filename).Equals("package.json", StringComparison.OrdinalIgnoreCase)) {
((IGroupableAnalysisProjectEntry)entries[file.Filename]).Analyze(CancellationToken.None, true);
}
}
foreach (var file in files) {
IJsProjectEntry projEntry;
if (entries.TryGetValue(file.Filename, out projEntry)) {
projEntry.AnalysisGroup.AnalyzeQueuedEntries(CancellationToken.None);
break;
}
}
return analyzer;
}
public override bool Equals(object obj)
{
AnalysisLimits other = obj as AnalysisLimits;
if (other != null)
{
return
(other.ReturnTypes == ReturnTypes &&
other.InstanceMembers == InstanceMembers &&
other.DictKeyTypes == DictKeyTypes &&
other.DictValueTypes == DictValueTypes &&
other.IndexTypes == IndexTypes &&
other.AssignedTypes == AssignedTypes &&
other.MergedArgumentTypes == MergedArgumentTypes &&
other.MaxArrayLiterals == MaxArrayLiterals &&
other.MaxObjectLiteralProperties == MaxObjectLiteralProperties &&
other.MaxObjectKeysTypes == MaxObjectKeysTypes &&
other.MaxMergeTypes == MaxMergeTypes);
}
return(false);
}
/// <summary>
/// Loads a new instance from the specified registry key.
/// </summary>
/// <param name="key">
/// The key to load settings from. If
/// null, all settings are assumed to be unspecified and the default
/// values are used.
/// </param>
/// <param name="defaults">
/// The default analysis limits if they're not available in the regkey.
/// </param>
public static AnalysisLimits LoadLimitsFromStorage(RegistryKey key, AnalysisLimits defaults) {
return new AnalysisLimits() {
ReturnTypes = GetSetting(key, ReturnTypesId) ?? defaults.ReturnTypes,
InstanceMembers = GetSetting(key, InstanceMembersId) ?? defaults.InstanceMembers,
DictKeyTypes = GetSetting(key, DictKeyTypesId) ?? defaults.DictKeyTypes,
DictValueTypes = GetSetting(key, DictValueTypesId) ?? defaults.DictValueTypes,
IndexTypes = GetSetting(key, IndexTypesId) ?? defaults.IndexTypes,
AssignedTypes = GetSetting(key, AssignedTypesId) ?? defaults.AssignedTypes,
NestedModulesLimit = GetSetting(key, NestedModulesLimitId) ?? defaults.NestedModulesLimit
};
}
private void CreateNewAnalyzer(AnalysisLimits limits) {
if (_analysisLevel == AnalysisLevel.NodeLsNone || _analysisLevel == AnalysisLevel.Preview) {
return;
}
_jsAnalyzer = new JsAnalyzer(limits);
if (ShouldEnqueue()) {
_analysisQueue = new AnalysisQueue(this);
}
_fullyLoaded = true;
}
private bool LoadCachedAnalysis(AnalysisLimits limits) {
if (_analysisLevel == AnalysisLevel.NodeLsNone || _analysisLevel == AnalysisLevel.Preview) {
return false;
}
string analysisDb = GetAnalysisPath();
if (File.Exists(analysisDb) && ShouldEnqueue()) {
FileStream stream = null;
bool disposeStream = true;
try {
stream = new FileStream(analysisDb, FileMode.Open);
byte[] header = new byte[DbHeader.Length];
stream.Read(header, 0, header.Length);
if (DbHeader.SequenceEqual(header)) {
var statusbar = (IVsStatusbar)NodejsPackage.GetGlobalService(typeof(SVsStatusbar));
if (statusbar != null) {
statusbar.SetText(SR.GetString(SR.StatusAnalysisLoading));
}
Task.Run(() => {
try {
using (new DebugTimer("LoadAnalysis")) {
var serializer = new AnalysisSerializer();
var analyzer = (JsAnalyzer)serializer.Deserialize(stream);
AnalysisQueue queue;
if (analyzer.Limits.Equals(limits)) {
queue = new AnalysisQueue(this);
foreach (var entry in analyzer.AllModules) {
_projectFiles[entry.FilePath] = new ProjectItem(entry);
}
_reparseDateTime = new FileInfo(analysisDb).LastWriteTime;
_analysisQueue = queue;
_jsAnalyzer = analyzer;
if (statusbar != null) {
statusbar.SetText(SR.GetString(SR.StatusAnalysisLoaded));
}
}
}
} catch (InvalidOperationException) {
// corrupt or invalid DB
if (statusbar != null) {
statusbar.SetText(SR.GetString(SR.StatusAnalysisLoadFailed));
}
} catch (Exception e) {
Debug.Fail(String.Format("Unexpected exception while loading analysis: {0}", e));
// bug in deserialization
if (statusbar != null) {
statusbar.SetText(SR.GetString(SR.StatusAnalysisLoadFailed));
}
} finally {
stream.Dispose();
// apply any changes
lock (_loadingDeltas) {
if (_jsAnalyzer == null) {
// we failed to load the cached analysis, create a new
// analyzer now...
CreateNewAnalyzer(LoadLimits());
}
_fullyLoaded = true;
foreach (var delta in _loadingDeltas) {
delta();
}
}
}
}).HandleAllExceptions(SR.GetString(SR.NodejsToolsForVisualStudio)).DoNotWait();
disposeStream = false;
return true;
}
} catch (IOException) {
} finally {
if (stream != null && disposeStream) {
stream.Dispose();
}
}
}
return false;
}
internal VsProjectAnalyzer(
AnalysisLevel analysisLevel,
bool saveToDisk,
string projectFileDir = null
) {
_projectFiles = new ConcurrentDictionary<string, ProjectItem>(StringComparer.OrdinalIgnoreCase);
_analysisLevel = analysisLevel;
_saveToDisk = saveToDisk;
_limits = LoadLimits();
if (projectFileDir != null) {
_projectFileDir = projectFileDir;
if (!LoadCachedAnalysis(_limits)) {
CreateNewAnalyzer(_limits);
}
} else {
_implicitProject = true;
CreateNewAnalyzer(_limits);
}
if (!_saveToDisk) {
DeleteAnalysis();
}
_userCount = 1;
InitializeCodeSettings();
}
private void CreateNewAnalyzer(AnalysisLimits limits) {
_jsAnalyzer = new JsAnalyzer(limits);
if (_analysisLevel != AnalysisLevel.None) {
_analysisQueue = new AnalysisQueue(this);
}
_fullyLoaded = true;
}
/// <summary>
/// Loads a new instance from the specified registry key.
/// </summary>
/// <param name="key">
/// The key to load settings from. If
/// null, all settings are assumed to be unspecified and the default
/// values are used.
/// </param>
/// <param name="defaults">
/// The default analysis limits if they're not available in the regkey.
/// </param>
private static AnalysisLimits LoadLimitsFromStorage(RegistryKey key, AnalysisLimits defaults) {
AnalysisLimits limits = new AnalysisLimits();
limits.ReturnTypes = GetSetting(key, ReturnTypesId) ?? defaults.ReturnTypes;
limits.InstanceMembers = GetSetting(key, InstanceMembersId) ?? defaults.InstanceMembers;
limits.DictKeyTypes = GetSetting(key, DictKeyTypesId) ?? defaults.DictKeyTypes;
limits.DictValueTypes = GetSetting(key, DictValueTypesId) ?? defaults.DictValueTypes;
limits.IndexTypes = GetSetting(key, IndexTypesId) ?? defaults.IndexTypes;
limits.AssignedTypes = GetSetting(key, AssignedTypesId) ?? defaults.AssignedTypes;
limits.NestedModulesLimit = GetSetting(key, NestedModulesLimitId) ?? defaults.NestedModulesLimit;
return limits;
}
private void CreateNewAnalyzer(AnalysisLimits limits) {
_jsAnalyzer = new JsAnalyzer(limits);
if (ShouldEnqueue()) {
_analysisQueue = new AnalysisQueue(this);
}
_fullyLoaded = true;
}
public static JsAnalyzer Analyze(AnalysisLimits limits, params AnalysisFile[] files) {
return Analyze(limits, null, files);
}
public static JsAnalyzer Analyze(string directory, AnalysisLimits limits = null, Action parseCallback = null) {
List<AnalysisFile> files = new List<AnalysisFile>();
foreach (var file in Directory.GetFiles(directory, "*", SearchOption.AllDirectories)) {
if (String.Equals(Path.GetExtension(file), ".js", StringComparison.OrdinalIgnoreCase)) {
var relativeFile = file.Substring(directory.Length);
files.Add(new AnalysisFile(file, File.ReadAllText(file)));
} else if (String.Equals(Path.GetFileName(file), "package.json", StringComparison.OrdinalIgnoreCase)) {
JavaScriptSerializer serializer = new JavaScriptSerializer();
Dictionary<string, object> json;
try {
json = serializer.Deserialize<Dictionary<string, object>>(File.ReadAllText(file));
} catch {
continue;
}
object mainFile;
if (json != null && json.TryGetValue("main", out mainFile) && mainFile is string) {
files.Add(AnalysisFile.PackageJson(file, (string)mainFile));
}
}
}
return Analyze(limits, parseCallback, files.ToArray());
}
public void AnalyzeX() {
var limits = new AnalysisLimits() {
ReturnTypes = 1,
AssignedTypes = 1,
DictKeyTypes = 1,
DictValueTypes = 1,
IndexTypes = 1,
InstanceMembers = 1
};
var sw = new Stopwatch();
sw.Start();
Analysis.Analyze("C:\\Source\\azure-sdk-tools-xplat", limits);
Console.WriteLine("Time: {0}", sw.Elapsed);
}
