/// <summary>
/// Merges this namespace definition with <paramref name="otherScope"/>. This happens when <c>otherScope.CanBeMergedInto(this)</c> evaluates to true.
/// </summary>
/// <param name="otherScope">the scope to merge with</param>
/// <returns>a new namespace definition from this and otherScope, or null if they couldn't be merged.</returns>
public override NamedScope Merge(NamedScope otherScope) {
NamespaceDefinition mergedScope = null;
if(otherScope != null) {
if(otherScope.CanBeMergedInto(this)) {
mergedScope = new NamespaceDefinition(this);
mergedScope.AddFrom(otherScope);
}
}
return mergedScope;
}
/// <summary>
/// Creates a NamespaceDefinition object for the given namespace typeUseElement. This must be one of the typeUseElement types defined in NamespaceElementNames.
/// </summary>
/// <param name="namespaceElement">the namespace element</param>
/// <param name="context">The parser context</param>
/// <returns>a new NamespaceDefinition object</returns>
public override void ParseNamespaceElement(XElement namespaceElement, ParserContext context) {
if(namespaceElement == null)
throw new ArgumentNullException("namespaceElement");
if(!NamespaceElementNames.Contains(namespaceElement.Name))
throw new ArgumentException(string.Format("Not a valid namespace typeUseElement: {0}", namespaceElement.Name), "namespaceElement");
var nameElement = namespaceElement.Element(SRC.Name);
var namespaceName = nameElement != null ? nameElement.Value : string.Empty;
var namespaceDefinition = new NamespaceDefinition { Name = namespaceName };
context.Push(namespaceDefinition);
}
/// <summary>
/// Creates a <see cref="NamespaceDefinition"/> object from this use (along with all of its descendants based on <see cref="NamedScopeUse.ChildScopeUse"/>).
/// </summary>
/// <returns>A new namespace definition based on this use</returns>
public override NamedScope CreateScope() {
var ns = new NamespaceDefinition
{
Name = this.Name,
ProgrammingLanguage = this.ProgrammingLanguage
};
ns.AddSourceLocation(this.Location);
if(ChildScopeUse != null) {
ns.AddChildScope(ChildScopeUse.CreateScope());
}
return ns;
}
/// <summary>
/// Parses a Java package directive
/// </summary>
/// <param name="namespaceElement">A file unit</param>
/// <param name="context">The parser context</param>
public override void ParseNamespaceElement(XElement namespaceElement, ParserContext context) {
var javaPackage = context.FileUnit.Elements(SRC.Package).FirstOrDefault();
// Add a global namespace definition
var globalNamespace = new NamespaceDefinition();
context.Push(globalNamespace);
if(null != javaPackage) {
var namespaceElements = from name in javaPackage.Elements(SRC.Name)
select name;
foreach(var name in namespaceElements) {
var namespaceForName = new NamespaceDefinition() {
Name = name.Value,
ProgrammingLanguage = ParserLanguage,
};
namespaceForName.AddSourceLocation(context.CreateLocation(name));
context.Push(namespaceForName, globalNamespace);
}
}
}
/// <summary>
/// Parses a C# namespace block
/// </summary>
/// <param name="namespaceElement">the namespace element to parse</param>
/// <param name="context">the parser context</param>
public override void ParseNamespaceElement(XElement namespaceElement, ParserContext context) {
if(namespaceElement == null) throw new ArgumentNullException("namespaceElement");
if(!NamespaceElementNames.Contains(namespaceElement.Name)) throw new ArgumentException(string.Format("Not a valid namespace element: {0}", namespaceElement.Name), "namespaceElement");
var nameElement = namespaceElement.Element(SRC.Name);
string namespaceName;
if(nameElement == null) {
namespaceName = string.Empty;
} else {
NamespaceDefinition root = null;
foreach(var name in NameHelper.GetNameElementsFromName(nameElement)) {
var namespaceForName = new NamespaceDefinition() {
Name = name.Value,
ProgrammingLanguage = ParserLanguage,
};
if(root == null) {
root = namespaceForName;
} else {
namespaceForName.AddSourceLocation(context.CreateLocation(name));
}
context.Push(namespaceForName, root);
}
}
}
/// <summary>
/// Creates a NamespaceDefinition object for the given namespace typeUseElement. This must
/// be one of the typeUseElement types defined in NamespaceElementNames.
/// </summary>
/// <param name="namespaceElement">the namespace element</param>
/// <param name="context">The parser context</param>
/// <returns>a new NamespaceDefinition object</returns>
protected override NamespaceDefinition ParseNamespaceElement(XElement namespaceElement, ParserContext context) {
if(namespaceElement == null)
throw new ArgumentNullException("namespaceElement");
if(!NamespaceElementNames.Contains(namespaceElement.Name))
throw new ArgumentException(string.Format("Not a valid namespace element: {0}", namespaceElement.Name), "namespaceElement");
if(context == null)
throw new ArgumentNullException("context");
var nameElement = namespaceElement.Element(SRC.Name);
var namespaceName = nameElement != null ? nameElement.Value : string.Empty;
var nd = new NamespaceDefinition {
Name = namespaceName,
ProgrammingLanguage = ParserLanguage,
};
nd.AddLocation(context.CreateLocation(namespaceElement));
//add children
var blockElement = namespaceElement.Element(SRC.Block);
if(blockElement != null) {
foreach(var child in blockElement.Elements()) {
nd.AddChildStatement(ParseStatement(child, context));
}
}
return nd;
}
private MethodDeclarationNode FromMethodCallToSWUM(MethodCall mcall, NamespaceDefinition globalNamespace, DataProject<CompleteWorkingSet> dataProject)
{
var mdef = globalNamespace.GetDescendants<MethodDefinition>().Where(decl => mcall.SignatureMatches(decl));
if (mdef.Count() > 0)
{
var mdefXml = DataHelpers.GetElement(dataProject.SourceArchive, mdef.First().PrimaryLocation);
MethodContext mc = ContextBuilder.BuildMethodContext(mdefXml);
MethodDeclarationNode mdn = new MethodDeclarationNode(mcall.Name, mc);
BaseVerbRule rule = new BaseVerbRule(posData, tagger, splitter);
if (rule.InClass(mdn))
{
rule.ConstructSwum(mdn);
return mdn;
}
else
{
return null;
}
}
else
{
Console.WriteLine(mcall.Name + " could not be found");
return null;
}
}
/// <summary>
/// Parses a C# namespace block
/// </summary>
/// <param name="namespaceElement">the namespace element to parse</param>
/// <param name="context">the parser context</param>
protected override NamespaceDefinition ParseNamespaceElement(XElement namespaceElement, ParserContext context) {
if(namespaceElement == null)
throw new ArgumentNullException("namespaceElement");
if(!NamespaceElementNames.Contains(namespaceElement.Name))
throw new ArgumentException(string.Format("Not a valid namespace element: {0}", namespaceElement.Name), "namespaceElement");
if(context == null)
throw new ArgumentNullException("context");
var nameElement = namespaceElement.Element(SRC.Name);
if(nameElement == null) {
throw new ParseException(context.FileName, namespaceElement.GetSrcLineNumber(), namespaceElement.GetSrcLinePosition(), this,
"No SRC.Name element found in namespace.", null);
}
//parse the name and create a NamespaceDefinition for each component
NamespaceDefinition topNS = null;
NamespaceDefinition lastNS = null;
foreach(var name in NameHelper.GetNameElementsFromName(nameElement)) {
var newNS = new NamespaceDefinition {
Name = name.Value,
ProgrammingLanguage = ParserLanguage
};
newNS.AddLocation(context.CreateLocation(name));
if(topNS == null) { topNS = newNS; }
if(lastNS != null) {
lastNS.AddChildStatement(newNS);
}
lastNS = newNS;
}
//add body of namespace to lastNS
var blockElement = namespaceElement.Element(SRC.Block);
if(blockElement != null) {
foreach(var child in blockElement.Elements()) {
lastNS.AddChildStatement(ParseStatement(child, context));
}
}
return topNS;
}
/// <summary>
/// Returns true if both this and <paramref name="otherScope"/> have the same name.
/// </summary>
/// <param name="otherScope">The scope to test</param>
/// <returns>true if they are the same namespace; false otherwise.</returns>
public virtual bool CanBeMergedInto(NamespaceDefinition otherScope) {
return base.CanBeMergedInto(otherScope);
}
/// <summary>
/// Copy constructor
/// </summary>
/// <param name="otherDefinition">The scope to copy from</param>
public NamespaceDefinition(NamespaceDefinition otherDefinition)
: base(otherDefinition) {}
private static void PrintScopeReport(NamespaceDefinition globalScope, string sourcePath, string csvDirectory) {
//var csvPath = Path.Combine(csvDirectory, "scopes.csv");
//Console.WriteLine("\nScope Report");
//Console.WriteLine("===============");
//var allScopes = VariableScopeIterator.Visit(globalScope);
//int numScopes = allScopes.Count();
//int numNamedScopes = allScopes.OfType<INamedScope>().Count();
//int numNamespaces = allScopes.OfType<NamespaceDefinition>().Count();
//int numTypes = allScopes.OfType<ITypeDefinition>().Count();
//int numMethods = allScopes.OfType<IMethodDefinition>().Count();
//Console.WriteLine("{0,10:N0} scopes", numScopes);
//Console.WriteLine("{0,10:N0} named scopes", numNamedScopes);
//Console.WriteLine("{0,10:N0} namespaces", numNamespaces);
//Console.WriteLine("{0,10:N0} types", numTypes);
//Console.WriteLine("{0,10:N0} methods", numMethods);
//if(!File.Exists(csvPath)) {
// File.WriteAllText(csvPath, String.Format("{0}{1}", String.Join(",", "Project", "Scopes", "Named Scopes", "Namespaces", "Types", "Methods"), Environment.NewLine));
//}
//File.AppendAllText(csvPath, String.Format("{0}{1}", String.Join(",", sourcePath, numScopes, numNamedScopes, numNamespaces, numTypes, numMethods), Environment.NewLine));
throw new NotImplementedException();
}
private static void PrintMethodCallReport(NamespaceDefinition globalScope, string sourcePath, string csvDirectory, string callLogPath) {
//TODO reimpleement once visitors have been modified
//var csvPath = Path.Combine(csvDirectory, "methodcalls.csv");
//Console.WriteLine("\nMethod Call Report");
//Console.WriteLine("===============");
//var methodCalls = from scope in VariableScopeIterator.Visit(globalScope)
// from call in scope.MethodCalls
// select call;
//int numMethodCalls = 0;
//int numMatchedMethodCalls = 0;
//Stopwatch sw = new Stopwatch();
//using(var callLog = new StreamWriter(callLogPath)) {
// foreach(var call in methodCalls) {
// sw.Start();
// var match = call.FindMatches().FirstOrDefault();
// sw.Stop();
// numMethodCalls++;
// if(null != match) {
// numMatchedMethodCalls++;
// callLog.WriteLine("{0} ({1}:{2}) -> {3} ({4}:{5})", call.Name, call.Location.SourceFileName, call.Location.StartingLineNumber, match.Name, match.PrimaryLocation.SourceFileName, match.PrimaryLocation.StartingLineNumber);
// }
// }
//}
//Console.WriteLine("{0,10:N0} method calls", numMethodCalls);
//Console.WriteLine("{0,10:N0} matched method calls ({1,8:P2})", numMatchedMethodCalls, ((float) numMatchedMethodCalls) / numMethodCalls);
//Console.WriteLine("{0,10:N0} matches / millisecond ({1,7:N0} ms elapsed)", ((float) numMethodCalls) / sw.ElapsedMilliseconds, sw.ElapsedMilliseconds);
//Console.WriteLine("See matched method calls in {0}", callLogPath);
//if(!File.Exists(csvPath)) {
// File.WriteAllText(csvPath, String.Format("{0}{1}", String.Join(",", "Project", "Method Calls", "Matched Method Calls", "Time (ms)"), Environment.NewLine));
//}
//File.AppendAllText(csvPath, String.Format("{0}{1}", String.Join(",", sourcePath, numMethodCalls, numMatchedMethodCalls, sw.ElapsedMilliseconds), Environment.NewLine));
throw new NotImplementedException();
}
private static void OutputCallGraphByType(NamespaceDefinition globalScope, string jsonPath) {
//TODO reimplement once MethodCalls has been reimplemented
//using(var writer = new JsonTextWriter(new StreamWriter(jsonPath))) {
// writer.WriteStartArray();
// foreach(var typeDefinition in globalScope.GetDescendantsAndSelf<TypeDefinition>()) {
// writer.WriteStartObject();
// writer.WritePropertyName("name");
// writer.WriteValue(typeDefinition.GetFullName());
// var calls = from scope in typeDefinition.GetDescendantsAndSelf()
// from call in scope.MethodCalls
// select call;
// writer.WritePropertyName("size");
// writer.WriteValue(calls.Count());
// // find the parent type of all the calls
// var callMatches = from call in calls
// let match = call.FindMatches().FirstOrDefault()
// where match != null
// let parentOfMatch = match.GetFirstParent<ITypeDefinition>()
// where parentOfMatch != null
// select parentOfMatch.GetFullName();
// // output the calls property and array
// writer.WritePropertyName("calls");
// writer.WriteStartArray();
// foreach(var call in callMatches) {
// writer.WriteValue(call);
// }
// writer.WriteEndArray();
// writer.WriteEndObject();
// }
// writer.WriteEndArray();
//}
throw new NotImplementedException();
}
/// <summary>
/// Parses a java file unit. This handles the "package" directive by calling
/// <see cref="ParseNamespaceElement"/>
/// </summary>
/// <param name="unitElement">The file unit to parse.</param>
/// <param name="context">The parser context to use.</param>
protected override NamespaceDefinition ParseUnitElement(XElement unitElement, ParserContext context) {
if(null == unitElement)
throw new ArgumentNullException("unitElement");
if(SRC.Unit != unitElement.Name)
throw new ArgumentException("should be a SRC.Unit", "unitElement");
if(context == null)
throw new ArgumentNullException("context");
context.FileUnit = unitElement;
//var aliases = from aliasStatement in GetAliasElementsForFile(unitElement)
// select ParseAliasElement(aliasStatement, context);
//context.Aliases = new Collection<Alias>(aliases.ToList());
//create a global namespace for the file unit
var namespaceForUnit = new NamespaceDefinition() {ProgrammingLanguage = ParserLanguage};
namespaceForUnit.AddLocation(context.CreateLocation(unitElement));
NamespaceDefinition bottomNamespace = namespaceForUnit;
//create a namespace for the package, and attach to global namespace
var packageElement = unitElement.Element(SRC.Package);
if(packageElement != null) {
var namespaceForPackage = ParseNamespaceElement(packageElement, context);
namespaceForUnit.AddChildStatement(namespaceForPackage);
bottomNamespace = namespaceForPackage.GetDescendantsAndSelf<NamespaceDefinition>().Last();
}
//add children to bottom namespace
foreach(var child in unitElement.Elements()) {
var childStmt = ParseStatement(child, context);
if(childStmt != null) {
bottomNamespace.AddChildStatement(childStmt);
}
}
return namespaceForUnit;
}
/// <summary>
/// Creates a NamespaceDefinition object from the given Java package element.
/// This will create a NamespaceDefinition for each component of the name, e.g. com.java.foo.bar, and link them as children of each other.
/// This will not add any child statements to the bottom namespace.
/// </summary>
/// <param name="packageElement">The SRC.Package element to parse.</param>
/// <param name="context">The parser context to use.</param>
/// <returns>A NamespaceDefinition corresponding to <paramref name="packageElement"/>.</returns>
protected override NamespaceDefinition ParseNamespaceElement(XElement packageElement, ParserContext context) {
if(packageElement == null)
throw new ArgumentNullException("packageElement");
if(packageElement.Name != SRC.Package)
throw new ArgumentException("must be a SRC.Package", "packageElement");
if(context == null)
throw new ArgumentNullException("context");
var nameElement = packageElement.Element(SRC.Name);
if(nameElement == null) {
throw new ParseException(context.FileName, packageElement.GetSrcLineNumber(), packageElement.GetSrcLinePosition(), this,
"No SRC.Name element found in namespace.", null);
}
//parse the name and create a NamespaceDefinition for each component
NamespaceDefinition topNS = null;
NamespaceDefinition lastNS = null;
foreach(var name in NameHelper.GetNameElementsFromName(nameElement)) {
var newNS = new NamespaceDefinition {
Name = name.Value,
ProgrammingLanguage = ParserLanguage
};
newNS.AddLocation(context.CreateLocation(name));
if(topNS == null) { topNS = newNS; }
if(lastNS != null) {
lastNS.AddChildStatement(newNS);
}
lastNS = newNS;
}
return topNS;
}
/// <summary>
/// Creates a global <see cref="NamespaceDefinition"/> object for <paramref name="unitElement"/> and pushes it onto <paramref name="context"/>
/// </summary>
/// <param name="unitElement">The element to parse</param>
/// <param name="context">The context to place the resulting namespace definition in</param>
public virtual void ParseUnitElement(XElement unitElement, ParserContext context) {
if(null == unitElement) throw new ArgumentNullException("unitElement");
if(SRC.Unit != unitElement.Name) throw new ArgumentException("should be a SRC.Unit", "unitElement");
context.FileUnit = unitElement;
var aliases = from aliasStatement in GetAliasElementsForFile(unitElement)
select ParseAliasElement(aliasStatement, context);
context.Aliases = new Collection<Alias>(aliases.ToList());
var namespaceForUnit = new NamespaceDefinition();
context.Push(namespaceForUnit);
}
