internal MethodEntityProcessor(MethodEntity methodEntity,
IDispatcher dispatcher, ICodeProvider codeProvider, IEntityDescriptor entityDescriptor = null,
bool verbose = false)
: base(methodEntity, entityDescriptor, dispatcher)
{
Contract.Assert(methodEntity != null);
this.MethodEntity = methodEntity;
this.EntityDescriptor = entityDescriptor==null?methodEntity.EntityDescriptor
:entityDescriptor;
this.Verbose = true; // verbose;
// It gets a code provider for the method.
if (codeProvider!=null || dispatcher is OrleansDispatcher)
{
this.codeProvider = codeProvider;
//this.codeProvider = ProjectGrainWrapper.CreateProjectGrainWrapperAsync(methodEntity.MethodDescriptor).Result;
//SetCodeProviderAsync(methodEntity.MethodDescriptor);
}
else
{
var pair = ProjectCodeProvider.GetProjectProviderAndSyntaxAsync(methodEntity.MethodDescriptor).Result;
if (pair != null)
{
this.codeProvider = pair.Item1;
}
}
// We use the codeProvider for Propagation and HandleCall and ReturnEvents (in the method DiffProp that uses IsAssignable)
// We can get rid of this by passing codeProvider as parameter in this 3 methods
this.MethodEntity.PropGraph.SetCodeProvider(this.codeProvider);
}
public void Generate(StreamWriter sw, ICodeProvider codeProvider)
{
StringBuilder sb = new StringBuilder();
AddStringCollection(sb, GetText(codeProvider));
sw.Write(sb.ToString());
}
public void Record(ICodeProvider codeProvider, params object[] args)
{
var step = Sequence.AddStep(codeProvider.Origin);
step.AddStatement(codeProvider.Code(args));
OnRecordAdded?.Invoke();
}
internal async Task<ISet<TypeDescriptor>> GetPotentialTypesAsync(PropGraphNodeDescriptor n, PropagationGraph propGraph, ICodeProvider codeProvider)
{
var result = new HashSet<TypeDescriptor>();
foreach (var typeDescriptor in propGraph.GetTypes(n))
{
// TO-DO fix by adding a where T: AnalysisType
if (typeDescriptor.IsConcreteType)
{
result.Add(typeDescriptor);
}
else
{
Contract.Assert(this.InstatiatedTypes != null);
foreach(var candidateType in this.InstatiatedTypes)
{
var isSubtype = await codeProvider.IsSubtypeAsync(candidateType, typeDescriptor);
if(isSubtype)
{
result.Add(candidateType);
}
}
}
}
return result;
}
public override void ExecuteCommandImpl(object sender, EventArgs args)
{
var project = projectManager.SelectedProject;
string projectConfigPath = projectManager.ProjectConfigPath;
string methodConfigPath = projectManager.MethodConfigPath;
var projectConfiguration = projectConfigurationManager.Load(projectConfigPath);
string selectedMethodPath = projectManager.MethodPath;
string selectedMethodName = Path.GetFileNameWithoutExtension(selectedMethodPath);
MethodInfo methodInformation = projectConfiguration.MethodInfos.FirstOrDefault(m => m.MethodName == selectedMethodName);
if (methodInformation == null)
{
throw new Exception();
}
var templateLoader = new TemplateLoader(this.dialogFactory);
templateLoader.Load(methodConfigPath);
var packageManager = new PackageManager(authManager);
var updateView = dialogFactory.GetUpdateFromArasView(projectConfigurationManager, projectConfiguration, templateLoader, packageManager, methodInformation, projectConfigPath, project.Name, project.FullName);
var updateViewResult = updateView.ShowDialog();
if (updateViewResult?.DialogOperationResult != true)
{
return;
}
var eventData = CommonData.EventSpecificDataTypeList.First(x => x.EventSpecificData == updateViewResult.EventSpecificData);
ICodeProvider codeProvider = codeProviderFactory.GetCodeProvider(project.CodeModel.Language, projectConfiguration);
GeneratedCodeInfo codeInfo = codeProvider.GenerateCodeInfo(updateViewResult.SelectedTemplate, eventData, updateViewResult.MethodName, false, updateViewResult.MethodCode, updateViewResult.IsUseVSFormattingCode);
projectManager.CreateMethodTree(codeInfo);
var methodInfo = new MethodInfo()
{
InnovatorMethodConfigId = updateViewResult.MethodConfigId,
InnovatorMethodId = updateViewResult.MethodId,
MethodLanguage = updateViewResult.MethodLanguage,
MethodName = updateViewResult.MethodName,
MethodType = updateViewResult.MethodType,
PackageName = updateViewResult.PackageName,
TemplateName = updateViewResult.SelectedTemplate.TemplateName,
EventData = updateViewResult.EventSpecificData,
ExecutionAllowedToId = updateViewResult.ExecutionIdentityId,
ExecutionAllowedToKeyedName = updateViewResult.ExecutionIdentityKeyedName,
MethodComment = updateViewResult.MethodComment,
PartialClasses = codeInfo.PartialCodeInfoList.Select(pci => pci.Path).ToList(),
ExternalItems = codeInfo.ExternalItemsInfoList.Select(pci => pci.Path).ToList()
};
projectConfiguration.AddMethodInfo(methodInfo);
projectConfiguration.UseVSFormatting = updateViewResult.IsUseVSFormattingCode;
projectConfigurationManager.Save(projectConfigPath, projectConfiguration);
}
private bool ModelToObject(object source, Type resultType, out object result)
{
result = null;
Type sourceType = source.GetType();
if ((ReflectionHelper.Is <IIdProvider>(sourceType) || ReflectionHelper.Is <ICodeProvider>(sourceType) || ReflectionHelper.Is <IGuidProvider>(sourceType)) &&
!this._coreManager.Contains(sourceType) &&
this._coreManager.Contains(resultType))
{
if (source is IIdProvider)
{
IIdProvider idProviderSource = source as IIdProvider;
result = this._coreManager.Get(idProviderSource.ID, resultType);
return(true);
}
else if (source is IGuidProvider)
{
IGuidProvider guidProviderSource = source as IGuidProvider;
result = this._coreManager.Get(guidProviderSource.Guid, resultType);
return(true);
}
else if (source is ICodeProvider)
{
ICodeProvider codeProviderSource = source as ICodeProvider;
result = this._coreManager.Get(codeProviderSource.Code, resultType);
return(true);
}
}
return(false);
}
public SimpleSubroutineBuilder(ICodeProvider <Label> codeProvider,
SubroutineFacade subroutineFacade,
Label entry)
: base(codeProvider, subroutineFacade, entry)
{
Initialize(entry);
}
public void Init()
{
projectManager = Substitute.For <IProjectManager>();
projectConfigurationManager = new ProjectConfigurationManager();
dialogFactory = Substitute.For <IDialogFactory>();
authManager = new AuthManagerStub();
codeProviderFactory = Substitute.For <ICodeProviderFactory>();
globalConfiguration = Substitute.For <IGlobalConfiguration>();;
CreateMethodCmd.Initialize(projectManager, authManager, dialogFactory, projectConfigurationManager, codeProviderFactory, globalConfiguration);
createMethodCmd = CreateMethodCmd.Instance;
iVsUIShell = Substitute.For <IVsUIShell>();
var currentPath = AppDomain.CurrentDomain.BaseDirectory;
projectManager.ProjectConfigPath.Returns(Path.Combine(currentPath, "TestData\\projectConfig.xml"));
projectManager.MethodConfigPath.Returns(Path.Combine(currentPath, "TestData\\method-config.xml"));
template = new TemplateInfo {
TemplateName = string.Empty
};
eventSpecificDataType = new EventSpecificDataType {
EventSpecificData = EventSpecificData.None
};
templateLoader = new TemplateLoader(dialogFactory);
packageManager = new PackageManager(authManager);
codeProvider = Substitute.For <ICodeProvider>();
projectConfiguration = projectConfigurationManager.Load(projectManager.ProjectConfigPath);
templateLoader.Load(projectManager.MethodConfigPath);
codeProviderFactory.GetCodeProvider(null, null).ReturnsForAnyArgs(codeProvider);
}
public override void ExecuteCommandImpl(object sender, EventArgs args)
{
Document activeDocument = projectManager.ActiveDocument;
SyntaxNode activeSyntaxNode = projectManager.ActiveSyntaxNode;
string activeDocumentMethodName = projectManager.ActiveDocumentMethodName;
string activeDocumentMethodFullPath = projectManager.ActiveDocumentMethodFullPath;
string activeDocumentMethodFolderPath = projectManager.ActiveDocumentMethodFolderPath;
string serverMethodFolderPath = projectManager.ServerMethodFolderPath;
MethodInfo methodInformation = projectConfigurationManager.CurrentProjectConfiguraiton.MethodInfos.FirstOrDefault(m => m.MethodName == activeDocumentMethodName);
if (string.Equals(activeDocument.FilePath, activeDocumentMethodFullPath, StringComparison.InvariantCultureIgnoreCase))
{
// main to external
var moveToViewAdapter = this.dialogFactory.GetMoveToView(activeDocumentMethodFolderPath, activeSyntaxNode);
var moveToViewResult = moveToViewAdapter.ShowDialog();
if (moveToViewResult.DialogOperationResult == false)
{
return;
}
ICodeProvider codeProvider = codeProviderFactory.GetCodeProvider(activeDocument.Project.Language);
CodeInfo activeDocumentCodeInfo = codeProvider.RemoveActiveNodeFromActiveDocument(activeDocument, activeSyntaxNode, serverMethodFolderPath);
CodeInfo itemCodeInfo = null;
if (moveToViewResult.SelectedCodeType == CodeType.Partial)
{
itemCodeInfo = codeProvider.InsertActiveNodeToPartial(moveToViewResult.SelectedFullPath, serverMethodFolderPath, activeDocumentMethodName, activeSyntaxNode, projectManager.ActiveDocumentMethodFullPath);
}
else
{
itemCodeInfo = codeProvider.InsertActiveNodeToExternal(moveToViewResult.SelectedFullPath, serverMethodFolderPath, activeDocumentMethodName, activeSyntaxNode, projectManager.ActiveDocumentMethodFullPath);
}
projectManager.AddItemTemplateToProjectNew(activeDocumentCodeInfo, methodInformation.Package.MethodFolderPath, false);
projectManager.AddItemTemplateToProjectNew(itemCodeInfo, methodInformation.Package.MethodFolderPath, false);
projectConfigurationManager.Save(projectManager.ProjectConfigPath);
}
else
{
// external to main
var messageBoxWindow = dialogFactory.GetMessageBoxWindow();
var messageBoxWindowResult = messageBoxWindow.ShowDialog(
this.messageManager.GetMessage("SelectedCodeWillBeMovedToMainMethodFileClickOKToContinue"),
this.messageManager.GetMessage("MoveToMainMethod"),
MessageButtons.OKCancel,
MessageIcon.Question);
if (messageBoxWindowResult == MessageDialogResult.OK)
{
ICodeProvider codeProvider = codeProviderFactory.GetCodeProvider(activeDocument.Project.Language);
CodeInfo activeDocumentCodeInfo = codeProvider.RemoveActiveNodeFromActiveDocument(activeDocument, activeSyntaxNode, serverMethodFolderPath);
CodeInfo methodDocumentCodeInfo = codeProvider.InsertActiveNodeToMainMethod(activeDocumentMethodFullPath, serverMethodFolderPath, activeSyntaxNode, activeDocument.FilePath);
projectManager.AddItemTemplateToProjectNew(activeDocumentCodeInfo, methodInformation.Package.MethodFolderPath, false);
projectManager.AddItemTemplateToProjectNew(methodDocumentCodeInfo, methodInformation.Package.MethodFolderPath, false);
}
}
}
public void GetCodeProvider_ShouldReturnCSharpCodeProvider(string projectLanguageCode)
{
// Act
ICodeProvider codeProvider = codeProviderFactory.GetCodeProvider(projectLanguageCode);
// Assert
Assert.IsInstanceOf(typeof(CSharpCodeProvider), codeProvider);
}
protected SubroutineBuilder(ICodeProvider <Label> codeProvider,
SubroutineFacade subroutineFacade,
Label entry)
{
this.SubroutineFacade = subroutineFacade;
CodeProvider = codeProvider;
AddTargetLabel(entry);
}
public override List <string> GetText(ICodeProvider codeProvider)
{
List <string> result = new List <string>();
result.Add("namespace " + name);
result.Add("{");
return(base.GetText(codeProvider));
}
public void Setup()
{
this.innovatorUser = new InnovatorUser();
this.serverConnection = Substitute.For <IServerConnection>();
this.innovatorInstance = new Innovator(this.serverConnection);
this.iOMWrapper = Substitute.For <IIOMWrapper>();
this.authManager = new AuthenticationManagerProxy(serverConnection, innovatorInstance, innovatorUser, iOMWrapper);
this.dialogFactory = Substitute.For <IDialogFactory>();
this.projectConfigurationManager = Substitute.For <IProjectConfigurationManager>();
this.projectConfiguration = Substitute.For <IProjectConfiguraiton>();
this.messageManager = Substitute.For <MessageManager>();
this.packageManager = new PackageManager(authManager, messageManager);
this.arasDataProvider = Substitute.For <IArasDataProvider>();
this.methodInformation = new MethodInfo();
this.templateLoader = new TemplateLoader();
this.projectManager = Substitute.For <IProjectManager>();
this.codeProvider = Substitute.For <ICodeProvider>();
this.globalConfiguration = Substitute.For <IGlobalConfiguration>();
this.globalConfiguration.GetUserCodeTemplatesPaths().Returns(new List <string>());
this.serverConnection.When(x => x.CallAction("ApplyItem", Arg.Is <XmlDocument>(doc => doc.DocumentElement.Attributes["type"].Value == "Value"), Arg.Any <XmlDocument>()))
.Do(x =>
{
(x[2] as XmlDocument).Load(Path.Combine(currentPath, @"Dialogs\ViewModels\TestData\ActionLocationsListValue.xml"));
});
this.serverConnection.When(x => x.CallAction("ApplyItem", Arg.Is <XmlDocument>(doc => doc.DocumentElement.Attributes["type"].Value == "Filter Value"), Arg.Any <XmlDocument>()))
.Do(x =>
{
(x[2] as XmlDocument).Load(Path.Combine(currentPath, @"Dialogs\ViewModels\TestData\MethodTypesListFilterValue.xml"));
});
this.projectConfiguration.LastSavedSearch.Returns(new Dictionary <string, List <PropertyInfo> >());
XmlDocument methodItemTypeAML = new XmlDocument();
methodItemTypeAML.Load(Path.Combine(currentPath, @"Dialogs\ViewModels\TestData\MethodItemType.xml"));
Item methodItemType = this.innovatorInstance.newItem();
methodItemType.loadAML(methodItemTypeAML.OuterXml);
this.arasDataProvider.GetMethodItemTypeInfo().Returns(new MethodItemTypeInfo(methodItemType, messageManager));
this.createMethodViewModel = new CreateMethodViewModel(authManager,
dialogFactory,
projectConfiguration,
templateLoader,
packageManager,
projectManager,
arasDataProvider,
codeProvider,
globalConfiguration,
messageManager);
}
public CallQuery(
ICodeProvider <Label, Local, Parameter, Method, Field, Type> codeProvider,
CallGraphOrder <Local, Parameter, Method, Field, Property, Event, Type, Attribute, Assembly> parent,
Node currentNode
)
{
this.codeProvider = codeProvider;
this.parent = parent;
this.currentNode = currentNode;
}
public void JsParserEventsHandler(JsParserEvent args)
{
_codeProvider = args.Code;
if (args is JsParserErrorsNotificationArgs args1)
{
SetErrors(args1);
return;
}
}
public void ExecuteCommandImpl_Partial_ShouldSaveConfigfile()
{
//Arange
string partialfileName = "testPartialfileName";
string methodName = "methodName";
Project selectedProject = Substitute.For <Project>();
selectedProject.CodeModel.Language.Returns("C#");
this.projectManager.MethodName.Returns(methodName);
this.projectManager.ServerMethodFolderPath.Returns(@"C:\Users\Vladimir\source\repos\Aras11SP15MethodProject12\Aras11SP15MethodProject12\ServerMethods\");
this.projectManager.SelectedFolderPath.Returns(@"C:\Users\Vladimir\source\repos\Aras11SP15MethodProject12\Aras11SP15MethodProject12\ServerMethods\MSO_Standard\Import\Method\MSO_GetAllSettings\Partials");
this.projectManager.SelectedProject.Returns(selectedProject);
this.projectManager.ProjectConfigPath.Returns("ProjectConfigPath");
MethodInfo testMethodInfo = new MethodInfo()
{
MethodName = methodName,
Package = new PackageInfo("MSO_Standard")
};
IProjectConfiguraiton projectConfiguraiton = Substitute.For <IProjectConfiguraiton>();
projectConfiguraiton.MethodInfos.Returns(new List <MethodInfo>()
{
testMethodInfo
});
projectConfigurationManager.CurrentProjectConfiguraiton.Returns(projectConfiguraiton);
CreateCodeItemViewAdaper createCodeItemViewAdaper = new CreateCodeItemViewAdaper(partialfileName, Aras.Method.Libs.Code.CodeType.Partial, true);
this.dialogFactory.GetCreateCodeItemView(Arg.Any <ICodeItemProvider>(), Arg.Any <bool>()).Returns(createCodeItemViewAdaper);
ICodeProvider codeProvider = Substitute.For <ICodeProvider>();
CodeInfo codeItemInfo = new CodeInfo()
{
Code = "code",
Path = @"path\testPartialfileName.cs"
};
codeProviderFactory.GetCodeProvider("C#").Returns(codeProvider);
codeProvider.CreatePartialCodeItemInfo(testMethodInfo, partialfileName, Arg.Any <CodeElementType>(), Arg.Any <bool>(), projectManager.ServerMethodFolderPath,
projectManager.SelectedFolderPath,
projectManager.MethodName,
this.templateLoader,
projectManager.MethodPath)
.Returns(codeItemInfo);
//Act
this.createCodeItemCmd.ExecuteCommandImpl(null, null);
//Assert
this.projectConfigurationManager.Received().Save("ProjectConfigPath");
}
/// <summary>
/// Send the error that occured in <see cref="ExecuteAsync"/>.
/// </summary>
internal static async Task SendErrorAsync(
IContext e,
string key,
object error,
ICodeProvider codeProvider,
object rangeObj = null)
{
var sb = new StringBuilder();
switch (rangeObj)
{
case SourceRange range:
{
var code = await codeProvider.GetAsync();
sb.AppendLine();
sb.AppendLine();
sb.Append(error);
sb.Append(" at ");
sb.Append(range.StartLine);
sb.Append(':');
sb.Append(range.StartColumn);
sb.AppendLine();
sb.AppendLine("```");
sb.Append(code.GetPeek(range.Index, range.Length));
sb.AppendLine("```");
break;
}
case CompiledSourceRange range:
{
var code = await codeProvider.GetAsync();
sb.AppendLine();
sb.AppendLine();
sb.Append(error);
sb.AppendLine();
sb.AppendLine("```");
sb.Append(code.GetPeek(range.Index, range.Length));
sb.AppendLine("```");
break;
}
default:
sb.AppendLine("```");
sb.Append(error);
sb.AppendLine();
sb.AppendLine("```");
break;
}
await e.ErrorEmbedResource(key)
.AppendDescription(sb.ToString())
.ToEmbed().QueueAsync(e, e.GetChannel());
}
private async ValueTask <bool> ExecuteAsync(IContext e, Block block, ICodeProvider codeProvider)
{
var isDonator = await userService.UserIsDonatorAsync((long)e.GetGuild().OwnerId);
var options = isDonator ? DonatorOptions : DefaultOptions;
var storage = await CreateStorageAsync(e, isDonator);
var say = new ScriptSayFunction();
var global = await CreateGlobalAsync(e, say);
var runner = e.GetService <Runner>();
var context = new Context(block, global, runner, options);
global["storage"] = storage;
try
{
await runner.ExecuteAsync(context);
await SendResultAsync(e, say);
await storage.UpdateAsync(context);
return(true);
}
catch (MiScriptLimitException ex)
{
var type = ex.Type switch
{
LimitType.Instructions => "instructions",
LimitType.Stack => "function calls",
LimitType.ArrayItems => "array items",
LimitType.ObjectItems => "object items",
LimitType.StringLength => "string size",
_ => throw new ArgumentOutOfRangeException()
};
await e.ErrorEmbedResource("user_error_miscript_limit", type)
.ToEmbed().QueueAsync(e, e.GetChannel());
}
catch (UserMiScriptException ex)
{
await SendErrorAsync(e, "user_error_miscript_execute", ex.Value, codeProvider, ex.Position);
}
catch (MiScriptException ex)
{
await SendErrorAsync(e, "error_miscript_execute", ex.Message, codeProvider, ex.Position);
}
catch (Exception ex)
{
await SendErrorAsync(e, "error_miscript_execute", "Internal error in MiScript: " + ex.Message, codeProvider);
}
return(false);
}
public void GetCodeProvider_NotSupporteCode_ShouldThrowNotSupportedException(string projectLanguageCode)
{
// Assert
NotSupportedException exception = Assert.Throws <NotSupportedException>(new TestDelegate(() =>
{
// Act
ICodeProvider codeProvider = codeProviderFactory.GetCodeProvider(projectLanguageCode);
}));
Assert.AreEqual(messageManager.GetMessage("CurrentProjectTypeIsNotSupported"), exception.Message);
}
public CsharpCompilationProvider(ISyntaxTreeProvider syntaxTreeProvider,
ICodeProvider codeProvider,
IFileNameProvider fileNameProvider,
IReferenceProvider referenceProvider,
ICompilationOptionProvider compilationOptionProvider)
{
_syntaxTreeProvider = syntaxTreeProvider;
_codeProvider = codeProvider;
_fileNameProvider = fileNameProvider;
_referenceProvider = referenceProvider;
_compilationOptionProvider = compilationOptionProvider;
}
public static string Get_Code(ICodeProvider obj)
{
Stream resourceStream;
if (TryGetResourceStream(obj.ResourceName, out resourceStream))
{
using (StreamReader reader = new StreamReader(resourceStream, Encoding.UTF8)) {
return(reader.ReadToEnd());
}
}
return(null);
}
public override void ExecuteCommandImpl(object sender, EventArgs args)
{
var project = projectManager.SelectedProject;
string selectedMethodName = projectManager.MethodName;
string serverMethodFolderPath = projectManager.ServerMethodFolderPath;
string selectedFolderPath = projectManager.SelectedFolderPath;
string projectConfigPath = projectManager.ProjectConfigPath;
var projectConfiguration = projectConfigurationManager.Load(projectConfigPath);
MethodInfo methodInformation = projectConfiguration.MethodInfos.FirstOrDefault(m => m.MethodName == selectedMethodName);
if (methodInformation == null)
{
throw new Exception($"Configurations for the {selectedMethodName} method not found.");
}
var view = dialogFactory.GetCreateCodeItemView(this.codeProviderFactory.GetCodeItemProvider(project.CodeModel.Language), projectConfiguration.UseVSFormatting);
var viewResult = view.ShowDialog();
if (viewResult?.DialogOperationResult != true)
{
return;
}
string codeItemPath = selectedFolderPath.Substring(serverMethodFolderPath.IndexOf(serverMethodFolderPath) + serverMethodFolderPath.Length);
codeItemPath = Path.Combine(codeItemPath, viewResult.FileName);
if (methodInformation.PartialClasses.Contains(codeItemPath, StringComparer.InvariantCultureIgnoreCase) ||
methodInformation.ExternalItems.Contains(codeItemPath, StringComparer.InvariantCultureIgnoreCase))
{
throw new Exception($"Code item already exists.");
}
ICodeProvider codeProvider = codeProviderFactory.GetCodeProvider(project.CodeModel.Language, projectConfiguration);
CodeInfo codeItemInfo = codeProvider.CreateCodeItemInfo(methodInformation, viewResult.FileName, viewResult.SelectedCodeType, viewResult.SelectedElementType, viewResult.IsUseVSFormattingCode);
projectManager.AddItemTemplateToProjectNew(codeItemInfo, true, 0);
if (viewResult.SelectedCodeType == CodeType.Partial)
{
methodInformation.PartialClasses.Add(codeItemInfo.Path);
}
else if (viewResult.SelectedCodeType == CodeType.External)
{
methodInformation.ExternalItems.Add(codeItemInfo.Path);
}
projectConfiguration.UseVSFormatting = viewResult.IsUseVSFormattingCode;
projectConfigurationManager.Save(projectManager.ProjectConfigPath, projectConfiguration);
}
public void ExecuteCommandImpl_External_ShouldSaveConfigfile()
{
//Arange
string externalfileName = "testExternalFileName";
string methodName = "methodName";
Project selectedProject = Substitute.For <Project>();
selectedProject.CodeModel.Language.Returns("C#");
this.projectManager.MethodName.Returns(methodName);
this.projectManager.SelectedProject.Returns(selectedProject);
this.projectManager.ProjectConfigPath.Returns("ProjectConfigPath");
MethodInfo testMethodInfo = new MethodInfo()
{
MethodName = methodName
};
IProjectConfiguraiton projectConfiguraiton = Substitute.For <IProjectConfiguraiton>();
projectConfiguraiton.MethodInfos.Returns(new List <MethodInfo>()
{
testMethodInfo
});
projectConfigurationManager.CurrentProjectConfiguraiton.Returns(projectConfiguraiton);
CreateCodeItemViewAdaper createCodeItemViewAdaper = new CreateCodeItemViewAdaper(externalfileName, Aras.Method.Libs.Code.CodeType.External, true);
this.dialogFactory.GetCreateCodeItemView(Arg.Any <ICodeItemProvider>(), Arg.Any <bool>()).Returns(createCodeItemViewAdaper);
ICodeProvider codeProvider = Substitute.For <ICodeProvider>();
CodeInfo codeItemInfo = new CodeInfo()
{
Code = "code",
Path = @"path\testExternalFileName.cs"
};
codeProviderFactory.GetCodeProvider("C#").Returns(codeProvider);
codeProvider.CreateExternalCodeItemInfo(testMethodInfo, externalfileName, Arg.Any <CodeElementType>(), Arg.Any <bool>(), this.projectManager.ServerMethodFolderPath,
this.projectManager.SelectedFolderPath,
this.projectManager.MethodName,
this.templateLoader,
this.projectManager.MethodPath)
.Returns(codeItemInfo);
//Act
this.createCodeItemCmd.ExecuteCommandImpl(null, null);
//Assert
this.projectConfigurationManager.Received().Save("ProjectConfigPath");
}
public Recorder(AutomationType automationType, CodeProviderFactory codeProviderFactory, string codeProviderName, Process targetProcess)
{
_automation = automationType == AutomationType.UIA2 ? (AutomationBase) new FlaUI.UIA2.UIA2Automation() : new FlaUI.UIA3.UIA3Automation();
_codeProvider = CreateCodeProvider(codeProviderFactory, codeProviderName, targetProcess);
State = RecorderState.Paused;
// Initialize workers
_workers.Add(new HoverWorker(_automation, targetProcess.Id));
var click = new ClickRecognizeWorker(_automation, targetProcess.Id);
click.ElementClicked += Click_ElementClicked;
click.ElementRightClicked += Click_ElementRightClicked;
_workers.Add(click);
}
public void Init()
{
serverConnection = Substitute.For <IServerConnection>();
Innovator innovatorIns = new Innovator(serverConnection);
this.authManager = new AuthenticationManagerProxy(this.serverConnection, innovatorIns, new InnovatorUser(), Substitute.For <IIOMWrapper>());
this.dialogFactory = Substitute.For <IDialogFactory>();
this.projectConfigurationManager = Substitute.For <IProjectConfigurationManager>();
this.projectConfiguration = Substitute.For <IProjectConfiguraiton>();
this.messageManager = Substitute.For <MessageManager>();
this.packageManager = new PackageManager(this.authManager, this.messageManager);
this.templateLoader = new TemplateLoader();
this.codeProvider = Substitute.For <ICodeProvider>();
this.projectManager = Substitute.For <IProjectManager>();
this.arasDataProvider = Substitute.For <IArasDataProvider>();
this.iOWrapper = Substitute.For <IIOWrapper>();
this.methodInformation = new MethodInfo()
{
MethodName = string.Empty,
Package = new PackageInfo(string.Empty)
};
this.projectConfiguration.LastSavedSearch.Returns(new Dictionary <string, List <PropertyInfo> >());
XmlDocument methodItemTypeDoc = new XmlDocument();
methodItemTypeDoc.Load(Path.Combine(currentPath, @"Dialogs\ViewModels\TestData\MethodItemType.xml"));
Item methodItemType = innovatorIns.newItem();
methodItemType.loadAML(methodItemTypeDoc.OuterXml);
MethodItemTypeInfo methodItemTypeInfo = new MethodItemTypeInfo(methodItemType, messageManager);
this.arasDataProvider.GetMethodItemTypeInfo().Returns(methodItemTypeInfo);
string pathToFileForSave = Path.Combine(currentPath, @"Dialogs\ViewModels\TestData\MethodAml\ReturnNullMethodAml.xml");
this.saveToPackageViewModel = new SaveToPackageViewModel(authManager,
dialogFactory,
projectConfiguration,
templateLoader,
packageManager,
codeProvider,
projectManager,
arasDataProvider,
iOWrapper,
messageManager,
methodInformation,
pathToFileForSave);
}
/// <summary>
/// Resolves branch instructions.
/// </summary>
public static void Resolve(IList <Branch> branches, ICodeProvider provider)
{
#if DEBUG
DebugHooks.LogInfo("ResolveBranches started");
#endif
for (int i = 0; i < branches.Count; ++i)
{
var br = branches[i].Source;
var bb = branches[i].TargetBlock;
if (br.IsSwitch)
{
var e = bb.FirstOut;
int deftarget = e.To.TranslatedEntryIndex;
var targets = new List <int>();
for (e = e.NextOut; e != null; e = e.NextOut)
{
targets.Add(e.To.TranslatedEntryIndex);
}
provider.SetCaseTargets(br, targets.ToArray(), deftarget);
}
else if (br.IsConditionalBranch)
{
var e = bb.TrueEdge;
provider.SetBranchTarget(br, e.To.TranslatedEntryIndex);
}
else //unconditional branch
{
#if DEBUG
if (!br.IsUnconditionalBranch) //sanity check
{
throw new ILTranslatorException("Invalid branch instruction");
}
#endif
var e = bb.FirstOut;
if (e.To != bb) //avoid cycle!
{
provider.SetBranchTarget(br, e.To.TranslatedEntryIndex);
}
else
{
provider.SetBranchTarget(br, bb.TranslatedExitIndex - 1);
}
}
}
#if DEBUG
DebugHooks.LogInfo("ResolveBranches succeeded");
#endif
}
public void ExecuteCommandImpl_ShouldAddPartialClassesAndSaveConfigfile()
{
//Arange
string partialfileName = "testPartialfileName";
string methodName = "methodName";
Project selectedProject = Substitute.For <Project>();
selectedProject.CodeModel.Language.Returns("C#");
this.projectManager.MethodName.Returns(methodName);
this.projectManager.SelectedProject.Returns(selectedProject);
this.projectManager.ProjectConfigPath.Returns("ProjectConfigPath");
MethodInfo testMethodInfo = new MethodInfo()
{
MethodName = methodName,
PartialClasses = new List <string>()
};
IProjectConfiguraiton projectConfiguraiton = Substitute.For <IProjectConfiguraiton>();
projectConfiguraiton.MethodInfos.Returns(new List <MethodInfo>()
{
testMethodInfo
});
this.projectConfigurationManager.Load(Arg.Any <string>()).Returns(projectConfiguraiton);
CreateCodeItemViewAdaper createCodeItemViewAdaper = new CreateCodeItemViewAdaper(partialfileName, MethodPlugin.Code.CodeType.Partial, true);
this.dialogFactory.GetCreateCodeItemView(Arg.Any <ICodeItemProvider>(), Arg.Any <bool>()).Returns(createCodeItemViewAdaper);
ICodeProvider codeProvider = Substitute.For <ICodeProvider>();
CodeInfo codeItemInfo = new CodeInfo()
{
Code = "code",
Path = @"path\testPartialfileName.cs"
};
codeProviderFactory.GetCodeProvider("C#", projectConfiguraiton).Returns(codeProvider);
codeProvider.CreateCodeItemInfo(testMethodInfo, partialfileName, Arg.Any <MethodPlugin.Code.CodeType>(), Arg.Any <CodeElementType>(), Arg.Any <bool>()).Returns(codeItemInfo);
//Act
this.createCodeItemCmd.ExecuteCommandImpl(null, null);
//Assert
Assert.IsTrue(testMethodInfo.PartialClasses.Contains(codeItemInfo.Path));
this.projectConfigurationManager.Received().Save("ProjectConfigPath", projectConfiguraiton);
}
public override void ExecuteCommandImpl(object sender, EventArgs args)
{
var project = projectManager.SelectedProject;
var projectConfiguration = projectConfigurationManager.Load(projectManager.ProjectConfigPath);
var templateLoader = new Templates.TemplateLoader(this.dialogFactory);
templateLoader.Load(projectManager.MethodConfigPath);
PackageManager packageManager = new PackageManager(authManager);
ICodeProvider codeProvider = codeProviderFactory.GetCodeProvider(project.CodeModel.Language, projectConfiguration);
var createView = dialogFactory.GetCreateView(projectConfiguration, templateLoader, packageManager, projectManager, codeProvider, globalConfiguration);
var createViewResult = createView.ShowDialog();
if (createViewResult?.DialogOperationResult != true)
{
return;
}
GeneratedCodeInfo codeInfo = codeProvider.GenerateCodeInfo(createViewResult.SelectedTemplate, createViewResult.SelectedEventSpecificData, createViewResult.MethodName, createViewResult.UseRecommendedDefaultCode, createViewResult.SelectedUserCodeTemplate.Code, createViewResult.IsUseVSFormattingCode);
projectManager.CreateMethodTree(codeInfo);
string newInnovatorMethodId = authManager.InnovatorInstance.getNewID();
var methodInfo = new MethodInfo()
{
InnovatorMethodConfigId = newInnovatorMethodId,
InnovatorMethodId = newInnovatorMethodId,
MethodLanguage = createViewResult.SelectedLanguage.Value,
MethodName = createViewResult.MethodName,
MethodType = createViewResult.SelectedActionLocation.Value,
MethodComment = createViewResult.MethodComment,
PackageName = createViewResult.SelectedPackage,
TemplateName = createViewResult.SelectedTemplate.TemplateName,
EventData = createViewResult.SelectedEventSpecificData.EventSpecificData,
ExecutionAllowedToId = createViewResult.SelectedIdentityId,
ExecutionAllowedToKeyedName = createViewResult.SelectedIdentityKeyedName,
PartialClasses = codeInfo.PartialCodeInfoList.Select(pci => pci.Path).ToList(),
ExternalItems = codeInfo.ExternalItemsInfoList.Select(pci => pci.Path).ToList()
};
projectConfiguration.AddMethodInfo(methodInfo);
projectConfiguration.UseVSFormatting = createViewResult.IsUseVSFormattingCode;
projectConfigurationManager.Save(projectManager.ProjectConfigPath, projectConfiguration);
}
public void Init()
{
projectManager = Substitute.For <IProjectManager>();
projectConfigurationManager = Substitute.For <ProjectConfigurationManager>();
dialogFactory = Substitute.For <IDialogFactory>();
authManager = new AuthManagerStub();
codeProviderFactory = Substitute.For <ICodeProviderFactory>();
codeProvider = Substitute.For <ICodeProvider>();
codeProviderFactory.GetCodeProvider(null).ReturnsForAnyArgs(codeProvider);
iVsUIShell = Substitute.For <IVsUIShell>();
var currentPath = AppDomain.CurrentDomain.BaseDirectory;
projectManager.ProjectConfigPath.Returns(Path.Combine(currentPath, "TestData\\projectConfig.xml"));
projectConfigurationManager.Load(projectManager.ProjectConfigPath);
projectManager.MethodName.Returns("TestMethod");
projectManager.MethodPath.Returns(Path.Combine(currentPath, "TestData\\TestMethod.txt"));
messageManager = Substitute.For <MessageManager>();
DebugMethodCmd.Initialize(projectManager, authManager, dialogFactory, projectConfigurationManager, codeProviderFactory, messageManager);
debugMethodCmd = DebugMethodCmd.Instance;
var project = Substitute.For <Project>();
var properties = Substitute.For <EnvDTE.Properties>();
var property = Substitute.For <Property>();
var propertiesForActiveConfigurations = Substitute.For <EnvDTE.Properties>();
var propertyForActiveConfiguration = Substitute.For <Property>();
var configurationManager = Substitute.For <ConfigurationManager>();
var activeConfigurator = Substitute.For <Configuration>();
projectManager.SelectedProject.Returns(project);
project.FileName.Returns(currentPath);
project.Properties.Returns(properties);
properties.Item(Arg.Any <string>()).Returns(property);
property.Value = "";
project.ConfigurationManager.Returns(configurationManager);
configurationManager.ActiveConfiguration.Returns(activeConfigurator);
activeConfigurator.Properties.Returns(propertiesForActiveConfigurations);
propertiesForActiveConfigurations.Item(Arg.Any <string>()).Returns(propertyForActiveConfiguration);
propertyForActiveConfiguration.Value = "";
projectManager.When(x => x.AttachToProcess(Arg.Any <System.Diagnostics.Process>())).Do(x => { });
var codeModel = Substitute.For <CodeModel>();
project.CodeModel.Returns(codeModel);
codeModel.Language.Returns("");
}
public bool TraceAggregateSequentally(Label current)
{
bool isCurrentBranches;
bool isCurrentHasSuccessor;
do
{
ICodeProvider <Label> codeProvider = this.parent.CodeProvider;
isCurrentBranches = codeProvider.Decode <BlockStartGatherer <Label>, Dummy, bool> (current, this, Dummy.Value);
isCurrentHasSuccessor = codeProvider.Next(current, out current);
if (isCurrentBranches && isCurrentHasSuccessor)
{
AddBlockStart(current);
}
} while (isCurrentHasSuccessor);
return(isCurrentBranches);
}
public void Init()
{
projectManager = Substitute.For <IProjectManager>();
projectConfigurationManager = Substitute.For <ProjectConfigurationManager>();
dialogFactory = Substitute.For <IDialogFactory>();
codeProviderFactory = Substitute.For <ICodeProviderFactory>();
CreatePartialElementCmd.Initialize(projectManager, dialogFactory, projectConfigurationManager, codeProviderFactory);
createPartialElementCmd = CreatePartialElementCmd.Instance;
iVsUIShell = Substitute.For <IVsUIShell>();
var currentPath = AppDomain.CurrentDomain.BaseDirectory;
projectManager.ProjectConfigPath.Returns(Path.Combine(currentPath, "TestData\\projectConfig.xml"));
projectManager.MethodName.Returns("TestMethod");
projectConfiguration = projectConfigurationManager.Load(projectManager.ProjectConfigPath);
projectConfiguration.UseVSFormatting = false;
codeProvider = Substitute.For <ICodeProvider>();
codeProviderFactory.GetCodeProvider(null, null).ReturnsForAnyArgs(codeProvider);
}
public Code(IMethod method, IClrMethodBody body, ICodeProvider provider)
{
if (method == null)
{
throw new ArgumentNullException("method");
}
if (body == null)
{
throw new ArgumentNullException("body");
}
if (provider == null)
{
throw new ArgumentNullException("provider");
}
Method = method;
Body = body;
Provider = provider;
}
public void CallParserForDocument(ICodeProvider codeProvider)
{
_activeDocFullName = codeProvider.FullName;
var result = _jsParserService.Process(codeProvider);
var toolWindow = _findWindowDelegate();
if (result == null)
{
// Not JS case - need to clean tree
_jsParserService.InvalidateCash();
if (toolWindow != null)
{
toolWindow.NavigationTreeView.Clear();
}
return;
}
if (result.IsEmpty)
{
// skip - cached result
return;
}
JsParserEventsBroadcaster.FireActionsForDoc(
_activeDocFullName,
new JsParserErrorsNotificationArgs
{
Code = codeProvider,
FullFileName = _activeDocFullName,
Errors = result.Errors
});
if (toolWindow != null)
{
NotifyColorChangeToToolWindow();
toolWindow.NavigationTreeView.UpdateTree(result, codeProvider);
}
}
internal ISet<TypeDescriptor> GetPotentialTypes(PropGraphNodeDescriptor n, PropagationGraph propGraph, ICodeProvider codeProvider)
{
var result = new HashSet<TypeDescriptor>();
foreach (var typeDescriptor in propGraph.GetTypes(n))
{
// TO-DO fix by adding a where T: AnalysisType
if (typeDescriptor.IsConcreteType)
{
result.Add(typeDescriptor);
}
else
{
// If it is a declaredTyped it means we were not able to compute a concrete type
// Therefore, we instantiate all compatible types for the set of instantiated types
//result.UnionWith(this.InstatiatedTypes.Where(iType => iType.IsSubtype(typeDescriptor)));
Contract.Assert(this.InstatiatedTypes != null);
// Diego: This requires a Code Provider. Now it will simply fail.
result.UnionWith(this.InstatiatedTypes.Where(candidateTypeDescriptor
=> codeProvider.IsSubtype(candidateTypeDescriptor, typeDescriptor)));
}
}
return result;
}
public JSParserResult Process(ICodeProvider codeProvider, bool skipHashCheck = false)
{
Code = codeProvider;
string docName = Path.Combine(Code.Path, Code.Name);
if (!CheckExt(docName))
{
return null;
}
var code = Code.LoadCode();
var hash = Convert.ToBase64String(MD5.Create().ComputeHash(Encoding.Default.GetBytes(code)));
if (!skipHashCheck && _loadedCodeHash == hash)
{
return new JSParserResult();
}
_loadedCodeHash = hash;
var parserSettings = new JavascriptParserSettings
{
MaxParametersLength = _settings.MaxParametersLength,
MaxParametersLengthInFunctionChain = _settings.MaxParametersLengthInFunctionChain,
SkipAnonymousFuntions = _settings.HideAnonymousFunctions,
Filename = docName,
ScriptStripEnabled = _settings.ScriptStripEnabled,
ScriptStripExtensions = _settings.ScriptStripExtensions.OfType<string>().ToArray(),
ToDoKeyWords = _settings.ToDoKeywords.OfType<string>().ToArray(),
FixAspNetTags = _settings.FixAspNetTags,
FixAspNetTagsExtensions = _settings.FixAspNetTagsExtensions.OfType<string>().ToArray(),
FixRazorSyntax = _settings.FixRazorSyntax,
FixRazorSyntaxExtensions = _settings.FixRazorSyntaxExtensions.OfType<string>().ToArray(),
};
var result = (new JavascriptParser(parserSettings)).Parse(code);
result.FileName = docName;
return result;
}
/// <summary>
/// Build the tree.
/// </summary>
public bool UpdateTree(JSParserResult result, ICodeProvider codeProvider)
{
if (result == null)
{
Clear();
return false;
}
if(string.IsNullOrEmpty(result.FileName))
{
return false;
}
StatisticsManager.Instance.Statistics.Container = codeProvider.ContainerName;
PerformNetworkActivity();
_lastParserResult = result;
_codeProvider = codeProvider;
_loadedDocName = _lastParserResult.FileName;
_expandedNodesManager.SetFile(_loadedDocName);
_marksManager.SetFile(_loadedDocName);
var isSort = Settings.SortingEnabled;
var isHierarchy = true;
_treeRefreshing = true;
treeView1.BeginUpdate();
treeView1.Nodes.Clear();
_tempTreeNodes.Clear();
_canExpand = true;
var nodes = result.Nodes;
if (result.Errors.Count > 0)
{
btnErrorDiagnosis.Visible = true;
btnErrorSeparator.Visible = true;
btnErrorDiagnosis.DropDownItems.Clear();
result.Errors.ForEach(er =>
{
var item = btnErrorDiagnosis.DropDownItems.Add(er.Message.SplitWordsByCamelCase() + ".\r\nLine: " + er.StartLine, null, ErrorDiagnosisClick);
item.Tag = er;
});
}
else
{
btnErrorDiagnosis.Visible = false;
btnErrorSeparator.Visible = false;
}
var tasksDataSource = new List<object>();
if (result.TaskList.Count > 0)
{
lbTaskList.Text = string.Format(" Task List: {0} items", result.TaskList.Count);
int i = 0;
result.TaskList.ForEach(t =>
{
++i;
var item = new {
No = i.ToString(),
Desc = t.Description,
Line = t.StartLine.ToString(),
};
tasksDataSource.Add(item);
});
splitContainer1.Panel2Collapsed = false;
SetToDoSplitterPosition();
}
else
{
splitContainer1.Panel2Collapsed = true;
tasksDataSource.Add(new {No = "", Desc="", Line="" }); //add fake row to workaround column sizing bug
}
taskListDataGrid.DataSource = tasksDataSource;
taskListDataGrid.CurrentCell = null;
_lastCodeLine = -1;
_functions = new List<CodeNode>();
FillNodes(nodes, treeView1.Nodes, 0, _functions);
if (!isHierarchy)
{
if (isSort)
{
_tempTreeNodes.Sort((n1, n2) => string.Compare(n1.Text, n2.Text));
}
foreach (TreeNode node in _tempTreeNodes)
{
treeView1.Nodes.Add(node);
}
}
if (filterByMarksToolStripMenuItem.Checked)
{
HideUnmarkedNodes(treeView1.Nodes);
}
treeView1.EndUpdate();
_treeRefreshing = false;
AdjustLineNumbersPanelSize();
panelLinesNumbers.Refresh();
return treeView1.Nodes.Count > 0;
}
/// <summary>
/// Use this method to add a <see cref="ICodeProvider"/> impelementation
/// that will be used when (and only) generating the final Composite.Generated.dll.
/// </summary>
/// <param name="codeProvider"></param>
public static void AddAssemblyCodeProvider(ICodeProvider codeProvider)
{
_dynamicallyAddedCodeProviders.Add(codeProvider);
}
internal void SetCodeProvider(ICodeProvider codeProvider)
{
this.codeProvider = codeProvider;
}
internal override ISet<MethodDescriptor> ComputeCalleesForNode(PropagationGraph propGraph, ICodeProvider codeProvider)
{
var calleesForNode = new HashSet<MethodDescriptor>();
if (this.Receiver != null)
{
// I replaced the invocation for a local call to mark that functionality is missing
//var callees = GetPotentialTypes(this.Receiver, propGraph)
// .Select(t => this.Callee.FindMethodImplementation(t));
var callees = GetPotentialTypes(this.Receiver, propGraph, codeProvider)
.Select(t => codeProvider.FindMethodImplementation(this.Callee,t));
calleesForNode.UnionWith(callees);
}
else
{
calleesForNode.Add(this.Callee);
}
return calleesForNode;
}
public void JsParserEventsHandler(JsParserEvent args)
{
_codeProvider = args.Code;
if (args is JsParserErrorsNotificationArgs)
{
SetErrors(((JsParserErrorsNotificationArgs)args));
return;
}
}
internal virtual Task<ISet<MethodDescriptor>> ComputeCalleesForNodeAsync(PropagationGraph propGraph, ICodeProvider codeProvider)
{
throw new NotImplementedException();
}
internal abstract ISet<MethodDescriptor> ComputeCalleesForNode(PropagationGraph propGraph, ICodeProvider codeProvider);
private async Task<ISet<MethodDescriptor>> GetDelegateCalleesAsync(VariableNode delegateNode, PropagationGraph propGraph, ICodeProvider codeProvider)
{
var callees = new HashSet<MethodDescriptor>();
var typeDescriptors = propGraph.GetTypes(delegateNode);
foreach (var delegateInstance in propGraph.GetDelegates(delegateNode))
{
if (typeDescriptors.Count() > 0)
{
foreach (var typeDescriptor in typeDescriptors)
{
// TO-DO!!!
// Ugly: I'll fix it
//var aMethod = delegateInstance.FindMethodImplementation(type);
var aMethod = await codeProvider.FindMethodImplementationAsync(delegateInstance, typeDescriptor);
callees.Add(aMethod);
}
}
else
{
// if Count is 0, it is a delegate that do not came form an instance variable
callees.Add(delegateInstance);
}
}
return callees;
}
internal override ISet<MethodDescriptor> ComputeCalleesForNode(PropagationGraph propGraph, ICodeProvider codeProvider)
{
return GetDelegateCallees(this.CalleeDelegate, propGraph, codeProvider);
}
internal async override Task<ISet<MethodDescriptor>> ComputeCalleesForNodeAsync(PropagationGraph propGraph, ICodeProvider codeProvider)
{
var calleesForNode = new HashSet<MethodDescriptor>();
if (this.Receiver != null)
{
// I replaced the invocation for a local call to mark that functionality is missing
//var callees = GetPotentialTypes(this.Receiver, propGraph)
// .Select(t => this.Callee.FindMethodImplementation(t));
foreach(var type in GetPotentialTypes(this.Receiver, propGraph, codeProvider))
{
var realCallee = await codeProvider.FindMethodImplementationAsync(this.Callee, type);
calleesForNode.Add(realCallee);
}
}
else
{
calleesForNode.Add(this.Callee);
}
return calleesForNode;
}
internal override async Task<ISet<MethodDescriptor>> ComputeCalleesForNodeAsync(PropagationGraph propGraph, ICodeProvider codeProvider)
{
return await GetDelegateCalleesAsync(this.CalleeDelegate, propGraph, codeProvider);
}
internal PropagationEffects Propagate(ICodeProvider codeProvider)
{
this.codeProvider = codeProvider;
var calls = new HashSet<AnalysisInvocationExpession>();
bool retModified = false;
while (workList.Count > 0)
{
var analysisNode = workList.First();
this.RemoveFromWorkList(analysisNode);
if (IsCallNode(analysisNode) || IsDelegateCallNode(analysisNode))
{
calls.Add(GetInvocationInfo(analysisNode));
continue;
}
if (IsRetNode(analysisNode))
{
retModified = true;
}
var v = GetVertex(analysisNode);
var types = GetTypes(analysisNode);
foreach (var v1 in graph.GetTargets(v.Id))
{
var n1 = GetAnalysisNode(v1);
DiffProp(types, n1);
var e = graph.GetEdge(v.Id, v1.Id);
e.Value.Types = types;
DiffPropDelegates(GetDelegates(analysisNode), n1);
}
}
HasBeenPropagated = true;
return new PropagationEffects(calls, retModified);
}
