private (string interfaceCode, string implementationCode) ApplyQuickFixToAppropriateInspectionResultsForImplementedInterface(
string interfaceCode,
string implementationCode,
Func <RubberduckParserState, IInspection> inspectionFactory,
Action <IQuickFix, IEnumerable <IInspectionResult>, IRewriteSession> applyQuickFix,
CodeKind codeKind)
{
var(vbe, interfaceModuleName, implementationModuleName) = TestVbeForImplementedInterface(interfaceCode, implementationCode);
var(state, rewriteManager) = MockParser.CreateAndParseWithRewritingManager(vbe);
using (state)
{
var inspection = inspectionFactory(state);
var inspectionResults = InspectionResults(inspection, state);
var rewriteSession = codeKind == CodeKind.AttributesCode
? rewriteManager.CheckOutAttributesSession()
: rewriteManager.CheckOutCodePaneSession();
var quickFix = QuickFix(state);
applyQuickFix(quickFix, inspectionResults, rewriteSession);
var actualInterfaceCode = rewriteSession.CheckOutModuleRewriter(interfaceModuleName).GetText();
var actualImplementationCode = rewriteSession.CheckOutModuleRewriter(implementationModuleName).GetText();
return(actualInterfaceCode, actualImplementationCode);
}
}
public IExtendedConsoleSession WriteCode(
string lexeme,
CodeKind codeKind)
{
var classification = _colorTheme.GetCodeClassification(codeKind);
return(Write(lexeme, classification.Foreground));
}
public SyntaxErrorException(string message, RecognitionException innerException, IToken offendingSymbol, int line, int position, CodeKind codeKind)
: base(message, innerException)
{
OffendingSymbol = offendingSymbol;
LineNumber = line;
Position = position;
CodeKind = codeKind;
}
public SyntaxErrorInfo(string message, RecognitionException innerException, IToken offendingSymbol, int line, int position, CodeKind codeKind)
{
Message = message;
Exception = innerException;
OffendingSymbol = offendingSymbol;
LineNumber = line;
Position = position;
CodeKind = codeKind;
}
protected string ApplyQuickFixToFirstInspectionResult(string inputCode,
Func <RubberduckParserState, IInspection> inspectionFactory,
CodeKind codeKind = CodeKind.CodePaneCode)
{
return(ApplyQuickFixToAppropriateInspectionResults(
inputCode,
inspectionFactory,
ApplyToFirstResult,
codeKind));
}
private IParseTree ParseSll(string moduleName, ITokenStream tokenStream, CodeKind codeKind)
{
var errorListener = _sllErrorListenerFactory.Create(moduleName, codeKind);
var tree = Parse(tokenStream, PredictionMode.Sll, errorListener);
if (errorListener.HasPostponedException(out var exception))
{
throw exception;
}
return(tree);
}
public CodeClassification GetCodeClassification(CodeKind codeKind)
{
if (!_codeKindMap.TryGetValue(codeKind, out var func))
{
throw new KeyNotFoundException();
}
var value = func(this);
return(value);
}
public (IParseTree tree, ITokenStream tokenStream) Parse(string moduleName, string projectId, string code, CancellationToken token,
CodeKind codeKind = CodeKind.SnippetCode, ParserMode parserMode = ParserMode.FallBackSllToLl)
{
token.ThrowIfCancellationRequested();
var tokenStream = _tokenStreamProvider.Tokens(code);
token.ThrowIfCancellationRequested();
var tree = _tokenStreamParser.Parse(moduleName, tokenStream, codeKind, parserMode);
return(tree, tokenStream);
}
/// <summary>
/// 根据名称获取编码
/// </summary>
/// <param name="kindName">编码类别</param>
/// <returns></returns>
public List <CodeContent> GetCodeContentByKind(string kindName)
{
List <CodeContent> res = new List <CodeContent>();
CodeKind codeKind = SelfDber.Entity <CodeKind>("where Kind=:Kind", new { Kind = kindName });
if (codeKind != null)
{
res = SelfDber.Entities <CodeContent>("where KindId=:KindId order by CodeOrder asc", new { KindId = codeKind.Id });
}
return(res);
}
protected string ApplyQuickFixToFirstInspectionResult(
IVBE vbe,
string componentName,
Func <RubberduckParserState, IInspection> inspectionFactory,
CodeKind codeKind = CodeKind.CodePaneCode)
{
return(ApplyQuickFixToAppropriateInspectionResults(
vbe,
componentName,
inspectionFactory,
ApplyToFirstResult,
codeKind));
}
protected (string interfaceCode, string implementationCode) ApplyQuickFixToFirstInspectionResultForImplementedInterface(
string interfaceInputCode,
string implementationInputCode,
Func <RubberduckParserState, IInspection> inspectionFactory,
CodeKind codeKind = CodeKind.CodePaneCode)
{
return(ApplyQuickFixToAppropriateInspectionResultsForImplementedInterface(
interfaceInputCode,
implementationInputCode,
inspectionFactory,
ApplyToFirstResult,
codeKind));
}
private IRewriteSession RewriteSession(CodeKind targetCodeKind)
{
switch (targetCodeKind)
{
case CodeKind.CodePaneCode:
return(_rewritingManager.CheckOutCodePaneSession());
case CodeKind.AttributesCode:
return(_rewritingManager.CheckOutAttributesSession());
default:
throw new NotSupportedException(nameof(targetCodeKind));
}
}
private string ApplyQuickFixToAppropriateInspectionResults(string inputCode,
Func <RubberduckParserState, IInspection> inspectionFactory,
Action <IQuickFix, IEnumerable <IInspectionResult>, IRewriteSession> applyQuickFix,
CodeKind codeKind)
{
var vbe = TestVbe(inputCode, out var component);
return(ApplyQuickFixToAppropriateInspectionResults(
vbe,
component.Name,
inspectionFactory,
applyQuickFix,
codeKind));
}
protected string ApplyQuickFixToFirstInspectionResultSatisfyingPredicate(
string code,
Func <RubberduckParserState, IInspection> inspectionFactory,
Func <IInspectionResult, bool> predicate,
CodeKind codeKind = CodeKind.CodePaneCode)
{
var applyQuickFix = ApplyToFirstResultSatisfyingPredicateAction(predicate);
return(ApplyQuickFixToAppropriateInspectionResults(
code,
inspectionFactory,
applyQuickFix,
codeKind));
}
protected (string interfaceCode, string implementationCode) ApplyQuickFixToFirstInspectionResultForImplementedInterfaceSatisfyingPredicate(
string interfaceInputCode,
string implementationInputCode,
Func <RubberduckParserState, IInspection> inspectionFactory,
Func <IInspectionResult, bool> predicate,
CodeKind codeKind = CodeKind.CodePaneCode)
{
var applyQuickFix = ApplyToFirstResultSatisfyingPredicateAction(predicate);
return(ApplyQuickFixToAppropriateInspectionResultsForImplementedInterface(
interfaceInputCode,
implementationInputCode,
inspectionFactory,
applyQuickFix,
codeKind));
}
public IParseTree Parse(string moduleName, CommonTokenStream tokenStream, CodeKind codeKind = CodeKind.SnippetCode,
ParserMode parserMode = ParserMode.FallBackSllToLl)
{
switch (parserMode)
{
case ParserMode.FallBackSllToLl:
return(ParseWithFallBack(moduleName, tokenStream, codeKind));
case ParserMode.LlOnly:
return(ParseLl(moduleName, tokenStream, codeKind));
case ParserMode.SllOnly:
return(ParseSll(moduleName, tokenStream, codeKind));
default:
throw new ArgumentException(nameof(parserMode));
}
}
private string ApplyQuickFixToAppropriateInspectionResults(string inputCode,
Func <RubberduckParserState, IInspection> inspectionFactory,
Action <IQuickFix, IEnumerable <IInspectionResult>, IRewriteSession> applyQuickFix,
CodeKind codeKind)
{
var vbe = TestVbe(inputCode, out var component);
var(state, rewriteManager) = MockParser.CreateAndParseWithRewritingManager(vbe);
using (state)
{
var inspection = inspectionFactory(state);
var inspectionResults = InspectionResults(inspection, state);
var rewriteSession = codeKind == CodeKind.AttributesCode
? rewriteManager.CheckOutAttributesSession()
: rewriteManager.CheckOutCodePaneSession();
var quickFix = QuickFix(state);
applyQuickFix(quickFix, inspectionResults, rewriteSession);
return(rewriteSession.CheckOutModuleRewriter(component.QualifiedModuleName).GetText());
}
}
private Mock <IExecutableRewriteSession> MockSession(Func <IRewriteSession, bool> rewritingAllowed, CodeKind targetCodeKind)
{
var mockSession = new Mock <IExecutableRewriteSession>();
mockSession.Setup(m => m.TryRewrite()).Callback(() => rewritingAllowed.Invoke(mockSession.Object));
var status = RewriteSessionState.Valid;
mockSession.SetupGet(m => m.Status).Returns(status);
mockSession.SetupSet(m => m.Status = It.IsAny <RewriteSessionState>())
.Callback <RewriteSessionState>(value =>
{
if (status == RewriteSessionState.Valid)
{
status = value;
mockSession.SetupGet(m => m.Status).Returns(status);
}
});
mockSession.Setup(m => m.TargetCodeKind).Returns(targetCodeKind);
var checkedOutModules = new HashSet <QualifiedModuleName>();
mockSession.Setup(m => m.CheckOutModuleRewriter(It.IsAny <QualifiedModuleName>()))
.Returns((QualifiedModuleName module) => null)
.Callback((QualifiedModuleName module) => checkedOutModules.Add(module));
mockSession.Setup(m => m.CheckedOutModules).Returns(() => checkedOutModules);
return(mockSession);
}
public ParsePassErrorListenerBase(string moduleName, CodeKind codeKind)
: base(codeKind)
{
ModuleName = moduleName;
}
public ParsePassSyntaxErrorException(string message, RecognitionException innerException, IToken offendingSymbol, int line, int position, string moduleName, CodeKind codeKind)
: base(message, innerException, offendingSymbol, line, position, codeKind)
{
ModuleName = moduleName;
CodeKind = codeKind;
}
private IExecutableRewriteSession RewriteSession(CodeKind codeKind)
{
return(codeKind == CodeKind.AttributesCode
? _rewritingManager.CheckOutAttributesSession()
: _rewritingManager.CheckOutCodePaneSession());
}
public IRubberduckParseErrorListener Create(CodeKind codeKind)
{
return(new ExceptionErrorListener(codeKind));
}
public ParsePassExceptionErrorListener(string moduleName, CodeKind codeKind)
: base(moduleName, codeKind)
{
}
public MainParseSyntaxErrorException(string message, RecognitionException innerException, IToken offendingSymbol, int line, int position, string moduleName, CodeKind codeKind)
: base(message, innerException, offendingSymbol, line, position, moduleName, codeKind)
{
}
private void WalkTrees(CodeInspectionSettings settings, RubberduckParserState state, IEnumerable <IParseTreeInspection> inspections, CodeKind codeKind)
{
var listeners = inspections
.Where(i => i.Severity != CodeInspectionSeverity.DoNotShow &&
i.TargetKindOfCode == codeKind &&
!IsDisabled(settings, i))
.Select(inspection => inspection.Listener)
.ToList();
if (!listeners.Any())
{
return;
}
List <KeyValuePair <QualifiedModuleName, IParseTree> > trees;
switch (codeKind)
{
case CodeKind.AttributesCode:
trees = state.AttributeParseTrees;
break;
case CodeKind.CodePaneCode:
trees = state.ParseTrees;
break;
default:
throw new ArgumentOutOfRangeException(nameof(codeKind), codeKind, null);
}
foreach (var componentTreePair in trees)
{
foreach (var listener in listeners)
{
listener.CurrentModuleName = componentTreePair.Key;
}
ParseTreeWalker.Default.Walk(new CombinedParseTreeListener(listeners), componentTreePair.Value);
}
}
public RubberduckParseErrorListenerBase(CodeKind codeKind)
{
CodeKind = codeKind;
}
public CommonTokenStream PreprocessTokenStream(string projectId, string moduleName, CommonTokenStream tokenStream, CancellationToken token, CodeKind codeKind = CodeKind.SnippetCode)
{
token.ThrowIfCancellationRequested();
var tree = _parser.Parse(moduleName, tokenStream, codeKind);
token.ThrowIfCancellationRequested();
var charStream = tokenStream.TokenSource.InputStream;
var symbolTable = new SymbolTable <string, IValue>();
var userCompilationArguments = _compilationArgumentsProvider.UserDefinedCompilationArguments(projectId);
var predefinedCompilationArgument = _compilationArgumentsProvider.PredefinedCompilationConstants;
var evaluator = new VBAPreprocessorVisitor(symbolTable, predefinedCompilationArgument, userCompilationArguments, charStream, tokenStream);
var expr = evaluator.Visit(tree);
var processedTokens = expr.Evaluate(); //This does the actual preprocessing of the token stream as a side effect.
tokenStream.Reset();
return(tokenStream);
}
public PreprocessorExceptionErrorListener(string moduleName, CodeKind codeKind)
: base(moduleName, codeKind)
{
}
public IRubberduckParseErrorListener Create(string moduleName, CodeKind codeKind)
{
return(new MainParseExceptionErrorListener(moduleName, codeKind));
}
public SyntaxErrorNotificationListener(CodeKind codeKind)
: base(codeKind)
{
}
