lint/libs/lint-checks/src/main/java/com/android/tools/lint/checks/SharedPrefsDetector.java - platform/tools/base - Git at Google

 /*
  * Copyright (C) 2012 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.tools.lint.checks;

 import static com.android.tools.lint.client.api.JavaParser.ResolvedMethod;
 import static com.android.tools.lint.client.api.JavaParser.ResolvedNode;
 import static com.android.tools.lint.client.api.JavaParser.TypeDescriptor;

 import com.android.annotations.NonNull;
 import com.android.annotations.Nullable;
 import com.android.tools.lint.client.api.JavaParser;
 import com.android.tools.lint.detector.api.Category;
 import com.android.tools.lint.detector.api.Context;
 import com.android.tools.lint.detector.api.Detector;
 import com.android.tools.lint.detector.api.Implementation;
 import com.android.tools.lint.detector.api.Issue;
 import com.android.tools.lint.detector.api.JavaContext;
 import com.android.tools.lint.detector.api.LintUtils;
 import com.android.tools.lint.detector.api.Scope;
 import com.android.tools.lint.detector.api.Severity;

 import java.io.File;
 import java.util.Collections;
 import java.util.List;

 import lombok.ast.Assert;
 import lombok.ast.AstVisitor;
 import lombok.ast.Block;
 import lombok.ast.Case;
 import lombok.ast.ClassDeclaration;
 import lombok.ast.ConstructorDeclaration;
 import lombok.ast.DoWhile;
 import lombok.ast.Expression;
 import lombok.ast.ExpressionStatement;
 import lombok.ast.For;
 import lombok.ast.ForwardingAstVisitor;
 import lombok.ast.If;
 import lombok.ast.MethodDeclaration;
 import lombok.ast.MethodInvocation;
 import lombok.ast.Node;
 import lombok.ast.NormalTypeBody;
 import lombok.ast.Return;
 import lombok.ast.Statement;
 import lombok.ast.VariableDeclaration;
 import lombok.ast.VariableDefinition;
 import lombok.ast.VariableReference;
 import lombok.ast.While;

 /**
  * Detector looking for SharedPreferences.edit() calls without a corresponding
  * commit() or apply() call
  */
 public class SharedPrefsDetector extends Detector implements Detector.JavaScanner {
     /** The main issue discovered by this detector */
     public static final Issue ISSUE = Issue.create(
             "CommitPrefEdits", //$NON-NLS-1$
             "Missing `commit()` on `SharedPreference` editor",

             "After calling `edit()` on a `SharedPreference`, you must call `commit()` " +
             "or `apply()` on the editor to save the results.",

             Category.CORRECTNESS,
             6,
             Severity.WARNING,
             new Implementation(
                     SharedPrefsDetector.class,
                     Scope.JAVA_FILE_SCOPE));

     public static final String ANDROID_CONTENT_SHARED_PREFERENCES =
             "android.content.SharedPreferences"; //$NON-NLS-1$
     private static final String ANDROID_CONTENT_SHARED_PREFERENCES_EDITOR =
             "android.content.SharedPreferences.Editor"; //$NON-NLS-1$

     /** Constructs a new {@link SharedPrefsDetector} check */
     public SharedPrefsDetector() {
     }

     @Override
     public boolean appliesTo(@NonNull Context context, @NonNull File file) {
         return true;
     }


     // ---- Implements JavaScanner ----

     @Override
     public List<String> getApplicableMethodNames() {
         return Collections.singletonList("edit"); //$NON-NLS-1$
     }

     @Nullable
     private static NormalTypeBody findSurroundingTypeBody(Node scope) {
         while (scope != null) {
             Class<? extends Node> type = scope.getClass();
             // The Lombok AST uses a flat hierarchy of node type implementation classes
             // so no need to do instanceof stuff here.
             if (type == NormalTypeBody.class) {
                 return (NormalTypeBody) scope;
             }

             scope = scope.getParent();
         }

         return null;
     }


     @Override
     public void visitMethod(@NonNull JavaContext context, @Nullable AstVisitor visitor,
             @NonNull MethodInvocation node) {
         assert node.astName().astValue().equals("edit");

         boolean verifiedType = false;
         ResolvedNode resolve = context.resolve(node);
         if (resolve instanceof ResolvedMethod) {
             ResolvedMethod method = (ResolvedMethod) resolve;
             TypeDescriptor returnType = method.getReturnType();
             if (returnType == null ||
                     !returnType.matchesName(ANDROID_CONTENT_SHARED_PREFERENCES_EDITOR)) {
                 return;
             }
             verifiedType = true;
         }

         Expression operand = node.astOperand();
         if (operand == null) {
             return;
         }

         // Looking for the specific pattern where you assign the edit() result
         // to a local variable; this means we won't recognize some other usages
         // of the API (e.g. assigning it to a previously declared variable) but
         // is needed until we have type attribution in the AST itself.
         Node parent = node.getParent();

         VariableDefinition definition = getLhs(parent);
         boolean allowCommitBeforeTarget;
         if (definition == null) {
             if (operand instanceof VariableReference) {
                 if (!verifiedType) {
                     NormalTypeBody body = findSurroundingTypeBody(parent);
                     if (body == null) {
                         return;
                     }
                     String variableName = ((VariableReference) operand).astIdentifier().astValue();
                     String type = getFieldType(body, variableName);
                     if (type == null || !type.equals("SharedPreferences")) { //$NON-NLS-1$
                         return;
                     }
                 }
                 allowCommitBeforeTarget = true;
             } else {
                 return;
             }
         } else {
             if (!verifiedType) {
                 String type = definition.astTypeReference().toString();
                 if (!type.endsWith("SharedPreferences.Editor")) {  //$NON-NLS-1$
                     if (!type.equals("Editor") ||                  //$NON-NLS-1$
                             !LintUtils.isImported(context.getCompilationUnit(),
                                     ANDROID_CONTENT_SHARED_PREFERENCES_EDITOR)) {
                         return;
                     }
                 }
             }
             allowCommitBeforeTarget = false;
         }

         Node method = JavaContext.findSurroundingMethod(parent);
         if (method == null) {
             return;
         }

         CommitFinder finder = new CommitFinder(context, node, allowCommitBeforeTarget);
         method.accept(finder);
         if (!finder.isCommitCalled()) {
             context.report(ISSUE, method, context.getLocation(node),
                 "`SharedPreferences.edit()` without a corresponding `commit()` or `apply()` call");
         }
     }

     @Nullable
     private static String getFieldType(@NonNull NormalTypeBody cls, @NonNull String name) {
         List<Node> children = cls.getChildren();
         for (Node child : children) {
             if (child.getClass() == VariableDeclaration.class) {
                 VariableDeclaration declaration = (VariableDeclaration) child;
                 VariableDefinition definition = declaration.astDefinition();
                 return definition.astTypeReference().toString();
             }
         }

         return null;
     }

     @Nullable
     private static VariableDefinition getLhs(@NonNull Node node) {
         while (node != null) {
             Class<? extends Node> type = node.getClass();
             // The Lombok AST uses a flat hierarchy of node type implementation classes
             // so no need to do instanceof stuff here.
             if (type == MethodDeclaration.class || type == ConstructorDeclaration.class) {
                 return null;
             }
             if (type == VariableDefinition.class) {
                 return (VariableDefinition) node;
             }

             node = node.getParent();
         }

         return null;
     }

     private static class CommitFinder extends ForwardingAstVisitor {
         /** The target edit call */
         private final MethodInvocation mTarget;
         /** whether it allows the commit call to be seen before the target node */
         private final boolean mAllowCommitBeforeTarget;

         private final JavaContext mContext;

         /** Whether we've found one of the commit/cancel methods */
         private boolean mFound;
         /** Whether we've seen the target edit node yet */
         private boolean mSeenTarget;

         private CommitFinder(JavaContext context, MethodInvocation target,
                 boolean allowCommitBeforeTarget) {
             mContext = context;
             mTarget = target;
             mAllowCommitBeforeTarget = allowCommitBeforeTarget;
         }

         @Override
         public boolean visitMethodInvocation(MethodInvocation node) {
             if (node == mTarget) {
                 mSeenTarget = true;
             } else if (mAllowCommitBeforeTarget || mSeenTarget || node.astOperand() == mTarget) {
                 String name = node.astName().astValue();
                 boolean isCommit = "commit".equals(name);
                 if (isCommit || "apply".equals(name)) { //$NON-NLS-1$ //$NON-NLS-2$
                     // TODO: Do more flow analysis to see whether we're really calling commit/apply
                     // on the right type of object?
                     mFound = true;

                     ResolvedNode resolved = mContext.resolve(node);
                     if (resolved instanceof JavaParser.ResolvedMethod) {
                         ResolvedMethod method = (ResolvedMethod) resolved;
                         JavaParser.ResolvedClass clz = method.getContainingClass();
                         if (clz.isSubclassOf("android.content.SharedPreferences.Editor", false)
                                 && mContext.getProject().getMinSdkVersion().getApiLevel() >= 9) {
                             // See if the return value is read: can only replace commit with
                             // apply if the return value is not considered
                             Node parent = node.getParent();
                             boolean returnValueIgnored = false;
                             if (parent instanceof MethodDeclaration ||
                                     parent instanceof ConstructorDeclaration ||
                                     parent instanceof ClassDeclaration ||
                                     parent instanceof Block ||
                                     parent instanceof ExpressionStatement) {
                                 returnValueIgnored = true;
                             } else if (parent instanceof Statement) {
                                 if (parent instanceof If) {
                                     returnValueIgnored = ((If) parent).astCondition() != node;
                                 } else if (parent instanceof Return) {
                                     returnValueIgnored = false;
                                 } else if (parent instanceof VariableDeclaration) {
                                     returnValueIgnored = false;
                                 } else if (parent instanceof For) {
                                     returnValueIgnored = ((For) parent).astCondition() != node;
                                 } else if (parent instanceof While) {
                                     returnValueIgnored = ((While) parent).astCondition() != node;
                                 } else if (parent instanceof DoWhile) {
                                     returnValueIgnored = ((DoWhile) parent).astCondition() != node;
                                 } else if (parent instanceof Case) {
                                     returnValueIgnored = ((Case) parent).astCondition() != node;
                                 } else if (parent instanceof Assert) {
                                     returnValueIgnored = ((Assert) parent).astAssertion() != node;
                                 } else {
                                     returnValueIgnored = true;
                                 }
                             }
                             if (returnValueIgnored && isCommit) {
                                 String message = "Consider using `apply()` instead; `commit` writes "
                                         + "its data to persistent storage immediately, whereas "
                                         + "`apply` will handle it in the background";
                                 mContext.report(ISSUE, node, mContext.getLocation(node), message);
                             }
                         }
                     }
                 }
             }

             return super.visitMethodInvocation(node);
         }

         @Override
         public boolean visitReturn(Return node) {
             if (node.astValue() == mTarget) {
                 // If you just do "return editor.commit() don't warn
                 mFound = true;
             }
             return super.visitReturn(node);
         }

         boolean isCommitCalled() {
             return mFound;
         }
     }
 }
	/*
	* Copyright (C) 2012 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.android.tools.lint.checks;

	import static com.android.tools.lint.client.api.JavaParser.ResolvedMethod;
	import static com.android.tools.lint.client.api.JavaParser.ResolvedNode;
	import static com.android.tools.lint.client.api.JavaParser.TypeDescriptor;

	import com.android.annotations.NonNull;
	import com.android.annotations.Nullable;
	import com.android.tools.lint.client.api.JavaParser;
	import com.android.tools.lint.detector.api.Category;
	import com.android.tools.lint.detector.api.Context;
	import com.android.tools.lint.detector.api.Detector;
	import com.android.tools.lint.detector.api.Implementation;
	import com.android.tools.lint.detector.api.Issue;
	import com.android.tools.lint.detector.api.JavaContext;
	import com.android.tools.lint.detector.api.LintUtils;
	import com.android.tools.lint.detector.api.Scope;
	import com.android.tools.lint.detector.api.Severity;

	import java.io.File;
	import java.util.Collections;
	import java.util.List;

	import lombok.ast.Assert;
	import lombok.ast.AstVisitor;
	import lombok.ast.Block;
	import lombok.ast.Case;
	import lombok.ast.ClassDeclaration;
	import lombok.ast.ConstructorDeclaration;
	import lombok.ast.DoWhile;
	import lombok.ast.Expression;
	import lombok.ast.ExpressionStatement;
	import lombok.ast.For;
	import lombok.ast.ForwardingAstVisitor;
	import lombok.ast.If;
	import lombok.ast.MethodDeclaration;
	import lombok.ast.MethodInvocation;
	import lombok.ast.Node;
	import lombok.ast.NormalTypeBody;
	import lombok.ast.Return;
	import lombok.ast.Statement;
	import lombok.ast.VariableDeclaration;
	import lombok.ast.VariableDefinition;
	import lombok.ast.VariableReference;
	import lombok.ast.While;

	/**
	* Detector looking for SharedPreferences.edit() calls without a corresponding
	* commit() or apply() call
	*/
	public class SharedPrefsDetector extends Detector implements Detector.JavaScanner {
	/** The main issue discovered by this detector */
	public static final Issue ISSUE = Issue.create(
	"CommitPrefEdits", //$NON-NLS-1$
	"Missing `commit()` on `SharedPreference` editor",

	"After calling `edit()` on a `SharedPreference`, you must call `commit()` " +
	"or `apply()` on the editor to save the results.",

	Category.CORRECTNESS,
	6,
	Severity.WARNING,
	new Implementation(
	SharedPrefsDetector.class,
	Scope.JAVA_FILE_SCOPE));

	public static final String ANDROID_CONTENT_SHARED_PREFERENCES =
	"android.content.SharedPreferences"; //$NON-NLS-1$
	private static final String ANDROID_CONTENT_SHARED_PREFERENCES_EDITOR =
	"android.content.SharedPreferences.Editor"; //$NON-NLS-1$

	/** Constructs a new {@link SharedPrefsDetector} check */
	public SharedPrefsDetector() {
	}

	@Override
	public boolean appliesTo(@NonNull Context context, @NonNull File file) {
	return true;
	}


	// ---- Implements JavaScanner ----

	@Override
	public List<String> getApplicableMethodNames() {
	return Collections.singletonList("edit"); //$NON-NLS-1$
	}

	@Nullable
	private static NormalTypeBody findSurroundingTypeBody(Node scope) {
	while (scope != null) {
	Class<? extends Node> type = scope.getClass();
	// The Lombok AST uses a flat hierarchy of node type implementation classes
	// so no need to do instanceof stuff here.
	if (type == NormalTypeBody.class) {
	return (NormalTypeBody) scope;
	}

	scope = scope.getParent();
	}

	return null;
	}


	@Override
	public void visitMethod(@NonNull JavaContext context, @Nullable AstVisitor visitor,
	@NonNull MethodInvocation node) {
	assert node.astName().astValue().equals("edit");

	boolean verifiedType = false;
	ResolvedNode resolve = context.resolve(node);
	if (resolve instanceof ResolvedMethod) {
	ResolvedMethod method = (ResolvedMethod) resolve;
	TypeDescriptor returnType = method.getReturnType();
	if (returnType == null \|\|
	!returnType.matchesName(ANDROID_CONTENT_SHARED_PREFERENCES_EDITOR)) {
	return;
	}
	verifiedType = true;
	}

	Expression operand = node.astOperand();
	if (operand == null) {
	return;
	}

	// Looking for the specific pattern where you assign the edit() result
	// to a local variable; this means we won't recognize some other usages
	// of the API (e.g. assigning it to a previously declared variable) but
	// is needed until we have type attribution in the AST itself.
	Node parent = node.getParent();

	VariableDefinition definition = getLhs(parent);
	boolean allowCommitBeforeTarget;
	if (definition == null) {
	if (operand instanceof VariableReference) {
	if (!verifiedType) {
	NormalTypeBody body = findSurroundingTypeBody(parent);
	if (body == null) {
	return;
	}
	String variableName = ((VariableReference) operand).astIdentifier().astValue();
	String type = getFieldType(body, variableName);
	if (type == null \|\| !type.equals("SharedPreferences")) { //$NON-NLS-1$
	return;
	}
	}
	allowCommitBeforeTarget = true;
	} else {
	return;
	}
	} else {
	if (!verifiedType) {
	String type = definition.astTypeReference().toString();
	if (!type.endsWith("SharedPreferences.Editor")) { //$NON-NLS-1$
	if (!type.equals("Editor") \|\| //$NON-NLS-1$
	!LintUtils.isImported(context.getCompilationUnit(),
	ANDROID_CONTENT_SHARED_PREFERENCES_EDITOR)) {
	return;
	}
	}
	}
	allowCommitBeforeTarget = false;
	}

	Node method = JavaContext.findSurroundingMethod(parent);
	if (method == null) {
	return;
	}

	CommitFinder finder = new CommitFinder(context, node, allowCommitBeforeTarget);
	method.accept(finder);
	if (!finder.isCommitCalled()) {
	context.report(ISSUE, method, context.getLocation(node),
	"`SharedPreferences.edit()` without a corresponding `commit()` or `apply()` call");
	}
	}

	@Nullable
	private static String getFieldType(@NonNull NormalTypeBody cls, @NonNull String name) {
	List<Node> children = cls.getChildren();
	for (Node child : children) {
	if (child.getClass() == VariableDeclaration.class) {
	VariableDeclaration declaration = (VariableDeclaration) child;
	VariableDefinition definition = declaration.astDefinition();
	return definition.astTypeReference().toString();
	}
	}

	return null;
	}

	@Nullable
	private static VariableDefinition getLhs(@NonNull Node node) {
	while (node != null) {
	Class<? extends Node> type = node.getClass();
	// The Lombok AST uses a flat hierarchy of node type implementation classes
	// so no need to do instanceof stuff here.
	if (type == MethodDeclaration.class \|\| type == ConstructorDeclaration.class) {
	return null;
	}
	if (type == VariableDefinition.class) {
	return (VariableDefinition) node;
	}

	node = node.getParent();
	}

	return null;
	}

	private static class CommitFinder extends ForwardingAstVisitor {
	/** The target edit call */
	private final MethodInvocation mTarget;
	/** whether it allows the commit call to be seen before the target node */
	private final boolean mAllowCommitBeforeTarget;

	private final JavaContext mContext;

	/** Whether we've found one of the commit/cancel methods */
	private boolean mFound;
	/** Whether we've seen the target edit node yet */
	private boolean mSeenTarget;

	private CommitFinder(JavaContext context, MethodInvocation target,
	boolean allowCommitBeforeTarget) {
	mContext = context;
	mTarget = target;
	mAllowCommitBeforeTarget = allowCommitBeforeTarget;
	}

	@Override
	public boolean visitMethodInvocation(MethodInvocation node) {
	if (node == mTarget) {
	mSeenTarget = true;
	} else if (mAllowCommitBeforeTarget \|\| mSeenTarget \|\| node.astOperand() == mTarget) {
	String name = node.astName().astValue();
	boolean isCommit = "commit".equals(name);
	if (isCommit \|\| "apply".equals(name)) { //$NON-NLS-1$ //$NON-NLS-2$
	// TODO: Do more flow analysis to see whether we're really calling commit/apply
	// on the right type of object?
	mFound = true;

	ResolvedNode resolved = mContext.resolve(node);
	if (resolved instanceof JavaParser.ResolvedMethod) {
	ResolvedMethod method = (ResolvedMethod) resolved;
	JavaParser.ResolvedClass clz = method.getContainingClass();
	if (clz.isSubclassOf("android.content.SharedPreferences.Editor", false)
	&& mContext.getProject().getMinSdkVersion().getApiLevel() >= 9) {
	// See if the return value is read: can only replace commit with
	// apply if the return value is not considered
	Node parent = node.getParent();
	boolean returnValueIgnored = false;
	if (parent instanceof MethodDeclaration \|\|
	parent instanceof ConstructorDeclaration \|\|
	parent instanceof ClassDeclaration \|\|
	parent instanceof Block \|\|
	parent instanceof ExpressionStatement) {
	returnValueIgnored = true;
	} else if (parent instanceof Statement) {
	if (parent instanceof If) {
	returnValueIgnored = ((If) parent).astCondition() != node;
	} else if (parent instanceof Return) {
	returnValueIgnored = false;
	} else if (parent instanceof VariableDeclaration) {
	returnValueIgnored = false;
	} else if (parent instanceof For) {
	returnValueIgnored = ((For) parent).astCondition() != node;
	} else if (parent instanceof While) {
	returnValueIgnored = ((While) parent).astCondition() != node;
	} else if (parent instanceof DoWhile) {
	returnValueIgnored = ((DoWhile) parent).astCondition() != node;
	} else if (parent instanceof Case) {
	returnValueIgnored = ((Case) parent).astCondition() != node;
	} else if (parent instanceof Assert) {
	returnValueIgnored = ((Assert) parent).astAssertion() != node;
	} else {
	returnValueIgnored = true;
	}
	}
	if (returnValueIgnored && isCommit) {
	String message = "Consider using `apply()` instead; `commit` writes "
	+ "its data to persistent storage immediately, whereas "
	+ "`apply` will handle it in the background";
	mContext.report(ISSUE, node, mContext.getLocation(node), message);
	}
	}
	}
	}
	}

	return super.visitMethodInvocation(node);
	}

	@Override
	public boolean visitReturn(Return node) {
	if (node.astValue() == mTarget) {
	// If you just do "return editor.commit() don't warn
	mFound = true;
	}
	return super.visitReturn(node);
	}

	boolean isCommitCalled() {
	return mFound;
	}
	}
	}