public void ExportDependency(string resultdir, DependencyInfo dependencyInfo)
{
if (
(null == dependencyInfo) ||
string.IsNullOrEmpty(resultdir)
)
{
return;
}
List <string> csvData = null;
resultdir = resultdir + "正向引用_" + DateTime.Now.ToString(m_dataFormat) + @"/";
foreach (var infoItem in dependencyInfo.DependencyInfoTbl)
{
AnalyseDependencyInfo(infoItem, out csvData);
WriteDependencyCSVFile(resultdir, infoItem.Key, csvData);
if (csvData != null)
{
csvData.Clear();
}
}
}
private static UnityEngine.Object ToObject(SearchItem item, Type type)
{
if (s_CurrentDependencyInfo)
{
ScriptableObject.DestroyImmediate(s_CurrentDependencyInfo);
}
s_CurrentDependencyInfo = ScriptableObject.CreateInstance <DependencyInfo>();
s_CurrentDependencyInfo.guid = item.id;
using (var context = SearchService.CreateContext(new string[] { providerId }, $"from:{item.id}"))
{
foreach (var r in SearchService.GetItems(context, SearchFlags.Synchronous))
{
var assetPath = AssetDatabase.GUIDToAssetPath(r.id);
if (string.IsNullOrEmpty(assetPath))
{
s_CurrentDependencyInfo.broken.Add(r.id);
}
else
{
var ur = AssetDatabase.LoadMainAssetAtPath(assetPath);
if (ur != null)
{
[email protected](ur);
}
else
{
s_CurrentDependencyInfo.untracked.Add($"{assetPath} ({r.id})");
}
}
}
}
using (var context = SearchService.CreateContext(new string[] { providerId }, $"to:{item.id}"))
{
foreach (var r in SearchService.GetItems(context, SearchFlags.Synchronous))
{
var assetPath = AssetDatabase.GUIDToAssetPath(r.id);
if (string.IsNullOrEmpty(assetPath))
{
s_CurrentDependencyInfo.broken.Add(r.id);
}
else
{
{
var ur = AssetDatabase.LoadMainAssetAtPath(assetPath);
if (ur != null)
{
s_CurrentDependencyInfo.usedBy.Add(ur);
}
else
{
s_CurrentDependencyInfo.untracked.Add($"{assetPath} ({r.id})");
}
}
}
}
}
return(s_CurrentDependencyInfo);
}
private string GetStatusText(DependencyInfo dependency)
{
var installedVersion = m_PackageDatabase.GetPackage(dependency.name)?.versions.installed;
if (installedVersion == null)
{
return(string.Empty);
}
if (installedVersion.HasTag(PackageTag.InDevelopment))
{
return(L10n.Tr("(in development)"));
}
if (installedVersion.HasTag(PackageTag.Local))
{
return(L10n.Tr("(local)"));
}
var statusText = installedVersion.HasTag(PackageTag.BuiltIn)
? L10n.Tr("enabled") : L10n.Tr("installed");
return(installedVersion.version?.ToString() == dependency.version
? string.Format("({0})", statusText) : string.Format("({0} {1})", installedVersion.version, statusText));
}
private static string GetStatusText(DependencyInfo dependency)
{
var installedVersion = PackageDatabase.instance.GetPackage(dependency.name)?.versions.installed;
if (installedVersion == null)
{
return(string.Empty);
}
if (installedVersion.HasTag(PackageTag.InDevelopment))
{
return(ApplicationUtil.instance.GetTranslationForText("(in development)"));
}
if (installedVersion.HasTag(PackageTag.Local))
{
return(ApplicationUtil.instance.GetTranslationForText("(local)"));
}
var statusText = installedVersion.HasTag(PackageTag.BuiltIn)
? ApplicationUtil.instance.GetTranslationForText("enabled") : ApplicationUtil.instance.GetTranslationForText("installed");
return(installedVersion.version?.ToString() == dependency.version
? string.Format("({0} \u2714)", statusText) : string.Format("({0} {1} \u2714)", installedVersion.version, statusText));
}
private static void ValidateDependency(DependencyInfo dep, string paramName)
{
if (dep == null)
{
throw new ArgumentException($"{nameof(DependencyInfo)} can not be null.", paramName);
}
if (string.IsNullOrEmpty(dep.FileName))
{
throw new ArgumentException($"{nameof(DependencyInfo)}.{nameof(DependencyInfo.FileName)} can not be null or empty.", paramName);
}
if (string.IsNullOrEmpty(dep.Text))
{
throw new ArgumentException($"{nameof(DependencyInfo)}.{nameof(DependencyInfo.Text)} can not be null or empty.", paramName);
}
if (dep.Source == null)
{
throw new ArgumentException($"{nameof(DependencyInfo)}.{nameof(DependencyInfo.Source)} can not be null.", paramName);
}
if (dep.Target == null)
{
throw new ArgumentException($"{nameof(DependencyInfo)}.{nameof(DependencyInfo.Target)} can not be null.", paramName);
}
}
private List <DependencyGroup> CreateDependencyGroups(IEnumerable <ProjectContext> projectContexts)
{
var libraryNameDependencyGroupMap = new Dictionary <string, DependencyGroup>();
foreach (var projectContext in projectContexts)
{
var libraries = projectContext.LibraryManager.GetLibraries();
foreach (var library in libraries)
{
var dependencyInfo = DependencyInfo.Create(projectContext, library);
if (libraryNameDependencyGroupMap.ContainsKey(dependencyInfo.Name))
{
var dependencyGroup = libraryNameDependencyGroupMap[dependencyInfo.Name];
dependencyGroup.AddEntry(dependencyInfo);
}
else
{
var dependencyGroup = DependencyGroup.CreateWithEntry(dependencyInfo);
libraryNameDependencyGroupMap[dependencyInfo.Name] = dependencyGroup;
}
}
}
return(libraryNameDependencyGroupMap.Values.ToList());
}
private static void AddDependenciesInfo(string bundleName, string relativePath, ref DependenciesInfo info,
ref ReservedSharedBundleInfo reserved, ref DependencyCache cache)
{
var dependencies = CollectDependencies(relativePath, ref cache);
var deps = dependencies.ToList();
deps.Add(relativePath);
foreach (var dependency in deps)
{
if (!info.ContainsKey(dependency))
{
info[dependency] = new DependencyInfo();
}
if (IsShader(dependency))
{
if (BundlerBuildSettings.kSeparateShaderBundle)
{
info[dependency].referenceInBundles.Add(BundlerBuildSettings.kSeparatedShaderBundleName);
reserved[dependency] = BundlerBuildSettings.kSeparatedShaderBundleName;
}
}
info[dependency].referenceInBundles.Add(bundleName);
}
}
public MockPackageVersion(string name)
{
this.name = name;
version = new SemVersion(1, 0, 0);
source = PackageSource.Embedded;
displayName = $"Mock Package {name}";
author = "Mock Author";
description = "Mock Description";
packageUniqueId = "123";
dependencies = new DependencyInfo[0];
resolvedDependencies = new DependencyInfo[0];
#if UNITY_2020_1_OR_NEWER
errors = new List <UIError>();
#else
errors = new List <Error>();
#endif
samples = new List <Sample>();
datePublished = DateTime.Now;
isInstalled = true;
isFullyFetched = true;
isUserVisible = true;
isAvailableOnDisk = true;
isVersionLocked = false;
canBeEmbedded = false;
canBeRemoved = true;
isDirectDependency = true;
}
private void UpdateDependencies(List <Dependency> updatedDependencies = null)
{
_repoPath = Path.Combine(Application.dataPath, "Repositories");
_rootDependenciesFile = Path.Combine(_repoPath, "Dependencies.json");
//Ensure to create directory structure and default dependencies if nothing exists
Directory.CreateDirectory(_repoPath);
if (!File.Exists(_rootDependenciesFile))
{
File.WriteAllText(_rootDependenciesFile, JsonUtility.ToJson(new DependencyInfo(), true));
}
string json = File.ReadAllText(_rootDependenciesFile);
_dependencies = JsonUtility.FromJson <DependencyInfo>(json);
//Sync file dependencies with in memory dependencies
if (updatedDependencies != null)
{
//Remove no longer existing
for (int i = _dependencies.Dependencies.Count - 1; i >= 0; i--)
{
var dep = _dependencies.Dependencies[i];
if (updatedDependencies.FindAll(d => d.Url == dep.Url).Count <= 0)
{
_dependencies.Dependencies.RemoveAt(i);
}
}
//Add new
foreach (var dep in updatedDependencies)
{
if (_dependencies.Dependencies.FindAll(d => d.Url == dep.Url).Count <= 0)
{
_dependencies.Dependencies.Add(dep);
}
}
json = JsonUtility.ToJson(_dependencies, true);
File.WriteAllText(_rootDependenciesFile, json);
}
//Update repo panels
_repoPanels = new List <RepoPanel>();
foreach (Dependency dependency in _dependencies.Dependencies)
{
if (_repoPanels.FindAll(p => dependency.Url == p.DependencyInfo.Url).Count == 0)
{
RepoPanel panel = new RepoPanel(_repoPath, dependency, GetPlatformAuthentication());
panel.OnRemovalRequested += OnPanelRemovalRequested;
panel.OnDeleteAssetsRequested += DeleteAssets;
panel.OnCopyFinished += (assets, updatedRepos) =>
{
UpdateAssetDatabaseForNewAssets(assets, EditorPrefs.GetBool(FULL_RE_IMPORT_KEY, true), updatedRepos);
};
_repoPanels.Add(panel);
}
}
Repaint();
}
public IPackageVersion GetPackageVersion(DependencyInfo info)
{
IPackage package;
IPackageVersion version;
GetUpmPackageAndVersion(info.name, info.version, out package, out version);
return(version);
}
public void Equals_WithEdgeCases_Works()
{
var target = new DependencyInfo();
Assert.AreEqual(target, target);
Assert.IsFalse(target.Equals(null));
Assert.IsFalse(target.Equals(this));
}
void MarkAndPreserve(AssemblyDefinition assembly, ExportedType type, TypePreserveMembers preserve)
{
var di = new DependencyInfo(DependencyKind.RootAssembly, assembly);
Context.Annotations.Mark(type, di);
Context.Annotations.Mark(assembly.MainModule, di);
Annotations.SetMembersPreserve(type, preserve);
}
public void GetHashCode_Works(DependencyInfo a, DependencyInfo b, bool areSame)
{
// in case instances are not equals, hashcodes still can collide
// so we don't Assert that they are different
if (areSame)
{
Assert.AreEqual(a.GetHashCode(), b.GetHashCode());
}
}
public void GetNumWorkersToScaleWith_GivenDependencyWithHalfCapacityAndNoWorkflow_ScalesByDependencyValuesAndATenth()
{
var numWorkersRequired = 100;
var expectedScalingFactor = 0.1;
var dependency = new DependencyInfo(true, 50);
var result = Utilities.GetNumWorkersToScaleWith(numWorkersRequired, "whatever", dependency, new List <string>());
result.Should().Be((int)(numWorkersRequired * expectedScalingFactor * (dependency.PercentAvailableResources * .01)));
}
/// <summary>
/// Registers an instance type
/// </summary>
/// <typeparam name="TContract"></typeparam>
/// <param name="instance"></param>
public void Register <TContract>(TContract instance)
{
if (typeof(TContract) == typeof(Type))
{
throw new ArgumentException("Cannot register the Type type as a contract.");
}
dependencies[typeof(TContract)] = new DependencyInfo(DependencyType.Instance, instance);
instances[typeof(TContract)] = instance;
}
private string BuildNameText(DependencyInfo dependency)
{
var packageInfo = Collection.LatestSearchPackages.FirstOrDefault(p => p.Name == dependency.name);
if (packageInfo != null)
{
return(packageInfo.DisplayName);
}
return(dependency.name);
}
private void DependencyResolvedHandler(DependencyInfo dependency)
{
if (this.resolvedDependencies.ContainsKey(dependency.Name) == true)
{
return;
}
this.resolvedDependencies[dependency.Name] = dependency.Value;
this.ContinueReadyConfiguration();
}
/// <summary>
/// Registers a concrete type
/// </summary>
/// <param name="type"></param>
/// <param name="isSingleton"></param>
public void Register(Type type, bool isSingleton)
{
if (type.IsInterface || type.IsAbstract)
{
throw new ArgumentException("Must register a concrete implementation.");
}
DependencyType dependencyType = isSingleton ? DependencyType.Singleton : DependencyType.Transient;
dependencies[type] = new DependencyInfo(dependencyType, type);
}
public static string GetVersionText(DependencyInfo dependency, IPackage package)
{
if (package == null || package.Is(PackageType.Feature))
{
return(string.Empty);
}
if (package.Is(PackageType.BuiltIn))
{
return("---");
}
return(dependency.version);
}
public void GetNumWorkersToScaleWith_GivenDependencyWithHalfCapacityAndPlaceInAWorkflow_ScalesByDependencyValuesAndWorkflowPosition()
{
var numWorkersRequired = 100;
var workflow = new List <string> {
"A", "B", "C"
};
var dependency = new DependencyInfo(true, 50);
var result = Utilities.GetNumWorkersToScaleWith(numWorkersRequired, "B", dependency, workflow);
result.Should().Be(34);
}
protected override void OnSetBelong()
{
var dep = dependencies.GetValue();
if (dep != null)
{
var array = dep as Array;
foreach (var item in array)
{
DependencyInfo info = new DependencyInfo(item.GetType());
info.SetInstance(item);
}
}
}
public List <string> GetDependentAssemblies(AssemblyInfo assembly)
{
SqlConnection conn = new SqlConnection(string.Format("Data Source={0};Initial Catalog={1};Integrated Security=SSPI;", GlobalProperties.DatabaseServer, GlobalProperties.MgmtDBName));
DependencyInfo di = new DependencyInfo();
BizTalkAssemblyName btsAssName = new BizTalkAssemblyName(assembly.Name, assembly.Version, assembly.Culture, assembly.PublicKeyToken);
List <BizTalkAssemblyName> list = di.GetUsedBy(conn, btsAssName);
foreach (BizTalkAssemblyName assn in di.GetDependencyOrderedAssemblyNames(conn, list))
{
dependentAssemblies.Add(assn.FullName);
}
return(dependentAssemblies);
}
public void ToString_Contains()
{
var target = new DependencyInfo
{
Parent = new AssemblyInfo {
Name = "p", Version = "1"
},
Child = new AssemblyInfo {
Name = "c", Version = "1"
},
};
var result = target.ToString();
Assert.That(result.Contains(target.Parent.ToString()));
Assert.That(result.Contains(target.Child.ToString()));
}
private void ScanFiles()
{
// If no includes were specified, add all files and subdirectories
// from the fileset's base directory to the fileset.
if ((FileSet.Includes.Count == 0) && (FileSet.AsIs.Count == 0))
{
FileSet.Includes.Add("**/*.dll");
// Make sure to rescan the fileset
FileSet.Scan();
}
AgentProjectInfo projectInfo = new AgentProjectInfo();
if (String.IsNullOrEmpty(ProjectToken))
{
projectInfo.Coordinates = new Coordinates(null, Project.ProjectName, null);
}
else
{
projectInfo.ProjectToken = ProjectToken;
}
// scan files and calculate SHA-1 values
List <DependencyInfo> dependencies = projectInfo.Dependencies;
foreach (String pathname in FileSet.FileNames)
{
FileInfo srcInfo = new FileInfo(pathname);
if (srcInfo.Exists)
{
String sha1 = ChecksumUtils.GetSha1Hash(pathname);
String filename = srcInfo.Name;
Log(Level.Debug, "SHA-1 for " + filename + " is: " + sha1);
DependencyInfo dependency = new DependencyInfo();
dependency.Sha1 = sha1;
dependency.ArtifactId = filename;
dependency.SystemPath = pathname;
dependencies.Add(dependency);
}
}
Log(Level.Info, "Found " + dependencies.Count + " direct dependencies");
projects.Add(projectInfo);
}
public REFERENCE_ANALYSE_ERROR_TYPE AnalyseDependency(out DependencyInfo dependencyInfo)
{
REFERENCE_ANALYSE_ERROR_TYPE errorType = REFERENCE_ANALYSE_ERROR_TYPE.REFERENCE_ANALYSE_ERROR_NONE;
dependencyInfo = new DependencyInfo();
do
{
errorType = CheckDependencyInput();
if (IsAnalserFailed(errorType))
{
break;
}
string configDir = UIAtlasEditorConfig.ReferenceResultPath;
AtlasReferenceFilter filter = new AtlasReferenceFilter(configDir);
List <string> assetPathTbl = GetAllAssetFilePath();
AnnalyseReferenceProgresser.GetInstance().InitProgresser(assetPathTbl.Count, "正向引用导出中");
int count = 1;
foreach (var item in assetPathTbl)
{
AtlasReferenceInfo newInfo = null;
if (
//YAMLAnalyser.IsAtlasPrefab(item)
!filter.CheckDependencyFilter(item)
)
{
YAMLAnalyser.AnalyseAtlasReferenceInfo(item, out newInfo);
if (newInfo != null)
{
dependencyInfo.DependencyInfoTbl.Add(item, newInfo);
}
}
AnnalyseReferenceProgresser.GetInstance().UpdateProgress(count++);
}
} while (false);
return(errorType);
}
public void Read_Single_ReturnsSingle()
{
var expected = new DependencyInfo
{
Parent = new AssemblyInfo {
Name = "parent", Version = "1.0"
},
Child = new AssemblyInfo {
Name = "child", Version = "1.0"
},
Distance = 1
};
var target = new IndirectDependencyGenerator();
var result = target.Filter(new[] { expected }).ToArray();
Assert.AreEqual(1, result.Length);
Assert.AreEqual(expected, result[0]);
}
/// <summary>
/// Formats a direct dependency for the end user
/// </summary>
/// <param name="dep"></param>
public void Log(DependencyInfo dep)
{
Assembly(dep.Parent);
Separator();
VisualDistance(dep.Distance);
Separator();
Assembly(dep.Child);
Separator();
using (The(Style.Primary, StyleGroup.Alternative))
{
output.Write(dep.Distance);
}
if (dep.Path.Count > 0)
{
Separator();
using (The(Style.Primary))
{
output.Write("(");
}
}
foreach (var part in dep.Path)
{
Separator();
Assembly(part);
}
if (dep.Path.Count > 0)
{
Separator();
using (The(Style.Primary))
{
output.Write(")");
}
}
NewLine();
}
private static string GetStatusText(DependencyInfo dependency)
{
var installedVersion = PackageDatabase.instance.GetPackage(dependency.name)?.installedVersion;
if (installedVersion == null)
{
return(string.Empty);
}
if (installedVersion.HasTag(PackageTag.InDevelopment))
{
return("(in development)");
}
if (installedVersion.HasTag(PackageTag.Local))
{
return("(local)");
}
return(installedVersion.version == dependency.version
? "(installed \u2714)" : $"({installedVersion.version} installed \u2714)");
}
private string BuildStatusText(DependencyInfo dependency)
{
SemVersion installedVersion;
if (Collection.ProjectDependencies.TryGetValue(dependency.name, out installedVersion))
{
if (installedVersion == PackageCollection.EmbdeddedVersion)
{
return("(in development)");
}
if (installedVersion == PackageCollection.LocalVersion)
{
return("(local)");
}
return(installedVersion == dependency.version
? "(installed \u2714)"
: string.Format("({0} installed \u2714)", installedVersion));
}
return(string.Empty);
}
public static string GetStatusText(DependencyInfo dependency, IPackageVersion installedVersion)
{
if (installedVersion == null)
{
return(string.Empty);
}
if (installedVersion.HasTag(PackageTag.Custom))
{
return(L10n.Tr("(custom)"));
}
if (installedVersion.HasTag(PackageTag.Local))
{
return(L10n.Tr("(local)"));
}
var statusText = installedVersion.HasTag(PackageTag.BuiltIn)
? L10n.Tr("enabled") : L10n.Tr("installed");
return(installedVersion.version?.ToString() == dependency.version
? string.Format("({0})", statusText) : string.Format("({0} {1})", installedVersion.version, statusText));
}
private SourceCompilerResults compileCore(IProgressMonitor monitor) {
var t0 = System.nanoTime();
var results = new SourceCompilerResults();
var hasErrors = false;
var errorManager = new CodeErrorManager();
var allFiles = parameters.AllFiles;
Iterable<IFile> filesToCompile = null;
try {
monitor.beginTask("", 11);
var deletedFiles = parameters.FilesToCompile
.select(p => allFiles.getResource(p))
.where(p => p == null || !p.exists())
.select(p => allFiles.getProjectRelativeName(p)).toSet();
var typesToCopy = Query.empty<TypeInfo>();
// Get the files to compile
if (parameters.FullBuild) {
filesToCompile = allFiles.getAllResources().where(p => p.exists()).toList();
} else {
bool filteringDone = false;
var referencingFiles = parameters.getDependencyInfo().getAllReferencingFiles(parameters.getFilesToCompile());
if (parameters.ProgressiveBuild && deletedFiles.isEmpty()) {
var referencedFiles = parameters.getDependencyInfo().getAllReferencedFiles(parameters.getFilesToCompile());
referencedFiles = referencedFiles.except(parameters.getFilesToCompile());
referencedFiles = referencedFiles.intersect(referencingFiles);
// Progressive build only if referenced and referencing files do not intersect
if (!referencedFiles.any()) {
filesToCompile = parameters.FilesToCompile.select(p => allFiles.getResource(p)).where(p => p.exists()).toList();
filteringDone = true;
}
}
if (!filteringDone) {
// Incremental build with dependencies
filesToCompile = referencingFiles.select(p => allFiles.getResource(p)).where(p => p.exists()).toList();
}
var filesToKeep = allFiles.getAllProjectRelativeNames().except(referencingFiles);
typesToCopy = filesToKeep.selectMany(p => parameters.DependencyInfo.getFileContents(p))
.where(p => p.indexOf('$') == -1).select(p => parameters.TypeSystem.getType(p));
Environment.trace(this, "keeping " + filesToKeep.count() + " files");
Environment.trace(this, "ignoring " +
(allFiles.getAllResources().count() - filesToCompile.count() - filesToKeep.count()) + " files");
}
Environment.trace(this, "compiling " + filesToCompile.count() + " files");
monitor.worked(1);
if (monitor.isCanceled()) {
throw new InterruptedException();
}
var compilationUnits = new HashMap<String, CompilationUnitNode>();
// Parsing
foreach (var file in filesToCompile) {
var text = getText(file);
if (text != null) {
parse(file, text, errorManager, compilationUnits);
}
}
monitor.worked(1);
if (monitor.isCanceled()) {
throw new InterruptedException();
}
// Compiling
var t1 = System.nanoTime();
var typeSystem = new Library(parameters.ClassPath);
JvmTypeSystemHelper.cloneTypes(typesToCopy, typeSystem);
var annotatedTypeSystem = new Library(new[] { Environment.getLibraryPath("stabal.jar") }, typeSystem);
var cparams = new CompilerParameters();
cparams.TypeSystem = typeSystem;
cparams.AnnotatedTypeSystem = annotatedTypeSystem;
cparams.GenerateClassFiles = parameters.GenerateClassFiles;
cparams.ProgressTracker = new CompilationProgressTracker(monitor);
var cunits = compilationUnits.values().toArray(new CompilationUnitNode[compilationUnits.size()]);
var cresults = new StabCompiler().compileFromCompilationUnits(cparams, cunits);
Environment.trace(this, "compilation of " + sizeof(cunits) + " files done in " + ((System.nanoTime() - t1) / 1e6) + "ms");
foreach (var error in cresults.Errors) {
if (error.Level == 0) {
hasErrors = true;
}
results.CodeErrors.add(error);
Environment.trace(this, "error (" + error.Line + ", " + error.Column + ") " + error.Filename + ": " + error.Message);
}
if (!hasErrors) {
var dependencyInfo = new DependencyInfo();
results.DependencyInfo = dependencyInfo;
var allTypes = new HashSet<String>();
// Copy informations from unbuilt files
if (parameters.DependencyInfo != null) {
var unbuiltFiles = allFiles.getAllProjectRelativeNames();
unbuiltFiles = unbuiltFiles.except(filesToCompile.select(p => allFiles.getProjectRelativeName(p)));
unbuiltFiles = unbuiltFiles.except(deletedFiles);
foreach (var file in unbuiltFiles) {
foreach (var type in parameters.DependencyInfo.getFileContents(file)) {
allTypes.add(type);
dependencyInfo.addFileToTypeRelation(file, type);
foreach (var refType in parameters.DependencyInfo.getReferencedTypes(type)) {
dependencyInfo.addTypeToTypeRelation(type, refType);
}
}
}
}
// Collect the types and update the dependencies.
var typeMembers = new HashMap<IFile, Iterable<TypeMemberNode>>();
foreach (var file in filesToCompile) {
var fileName = allFiles.getProjectRelativeName(file);
var compilationUnit = compilationUnits[fileName];
if (compilationUnit == null) {
continue;
}
var members = SyntaxTreeHelper.getTypeMembers(compilationUnit);
typeMembers.put(file, members);
foreach (var member in members) {
var typeName = member.getUserData(typeof(TypeInfo)).FullName;
dependencyInfo.addFileToTypeRelation(fileName, typeName);
allTypes.add(typeName);
}
}
if (parameters.DependencyInfo != null) {
// Copy the types ignored by this compilation
var missingTypes = new HashSet<TypeInfo>();
foreach (var t in allTypes.where(p => p.indexOf('$') == -1 && !typeSystem.typeExists(p))) {
if (hasErrors = !parameters.DependencyInfo.getReferencedTypes(t).all(p => allTypes.contains(p))) {
Environment.trace(this, "Incremental build failed: a type was deleted");
break;
}
missingTypes.add(parameters.TypeSystem.getType(t));
}
if (!hasErrors) {
JvmTypeSystemHelper.cloneTypes(missingTypes, typeSystem);
}
}
if (!hasErrors) {
// Compute the dependencies in the compiled files
foreach (var member in filesToCompile.select(p => typeMembers[p]).where(p => p != null).selectMany(p => p)) {
foreach (var t in SyntaxTreeHelper.getTypeMemberDependencies(member)
.intersect(allTypes.select(p => JvmTypeSystemHelper.getType(typeSystem, p)))) {
dependencyInfo.addTypeToTypeRelation(member.getUserData(typeof(TypeInfo)).FullName, t.FullName);
}
}
results.TypeSystem = typeSystem;
results.AnnotatedTypeSystem = annotatedTypeSystem;
foreach (var e in compilationUnits.entrySet()) {
results.CompilationUnits[e.Key] = e.Value;
}
foreach (var e in cresults.ClassFiles.entrySet()) {
results.ClassFiles[e.Key] = e.Value;
}
}
}
monitor.worked(1);
} catch (CodeErrorException e) {
monitor.worked(10);
} catch (TypeLoadException e) {
results.MissingType = e.TypeName;
hasErrors = true;
monitor.worked(6);
} finally {
monitor.done();
}
foreach (var file in filesToCompile) {
results.CompiledFiles.add(allFiles.getProjectRelativeName(file));
}
foreach (var error in errorManager.Errors) {
if (error.Level == 0) {
hasErrors = true;
}
results.CodeErrors.add(error);
Environment.trace(this, "error (" + error.Line + ", " + error.Column + ") " + error.Filename + ": " + error.Message);
}
results.Failed = hasErrors;
Environment.trace(this, "compilation done in " + ((System.nanoTime() - t0) / 1e6) + "ms");
return results;
}
